注册对应Handler|B[event_router.
event_trigger_tree] > E[复杂对象] -->|封装|ZE[ZSimEvent1] > ZE -->|封装|EP > ZE1[ZSimEvent2] -->|封装|EP[事件画像
EventProfile] > ZE2[ZSimEvent3] -->|封装|EP > ZE3[ZSimEvent4] -->|封装|EP > ZE4[...] -->|封装|EP > EP -->|提供信息|B > B -->|激活|N[节点] > N-->|执行|P[publish
事件] > P -->|调用|H[BuffHandler] > H -->|调用|B1[buff.start
buff.end
...] > H-->|发布|B2[Buff更新事件] > B2-->|调用|BM[BuffManager
执行CRUD] > ``` ## **Buff的分类** ### 注意，在理念上，这些Buff需要被进行分类，但是在实现过程中，Buff是不分类的。这里的分类讨论只是为了明确Buff的业务逻辑框架。根据Buff的功能性，我们可以将Buff分成2类 - 增减益Buff：这类Buff总是会给予对象**数值上的改变**，比如：增幅、削弱属性，影响乘区等； - 触发器Buff：这类Buff不包含任何的数值改变，但是它的触发本身会导致一些其他事情的发生——可能是造成一些附加伤害、可能是触发别的Buff、或者是修改角色某个特殊状态等 不光是ZSim，可以说所有游戏中的Buff都可以被概括为这两个类别。 **这一Buff分类准则作为ZSimBuff系统的底层设计，在本次重构中并未改变。只是，新系统重，不同类型的Buff需要构建不同给的Handler来处理它们的业务逻辑** ## **Buff的生命周期管理（CRUD）：** - Buff的创建 - Buff只在初始化时被创建，在整个模拟过程中，构造函数只被调用一次。新架构中，Buff对象只有一个，由该Buff对象来统一记录、管理不同对象身上的Buff的情况（持续时间、层数等） - Buff在创建时，还需要根据自身的`logic_id`中记录的子条件组合，调用`event_router`的注册器，将自己注册到对应的逻辑树节点上。 - Buff的新增/刷新： - Buff的新增、刷新事件业务链： 1. `event_router`提供的事件画像触发了逻辑树上的对应节点，节点激活时，会调用`publish`方法，调用`buff_event_handler`来调用buff的`start`和`end`方法，同时发布一个`buff更新事件`. 2. `buff.start()`或者`buff.end()`方法调用时，会更新自身的信息， 3. `BuffManager`收到`buff更新事件`时，会执行对应角色的Buff增删操作。 - Buff的查找： - 通过调用`buff_manager`的对应接口来实现Buff的查找 - Buff的消退： - Buff的消退的流程和其新增流程类似，同样是通过`event_router`或是`GlobalBuffController`抛出事件、调用对应的Handler执行。注意，部分Buff的消退不依赖于自然时间的流逝，而是具有特殊的判定行为，这部分业务交由`event_router`的逻辑树管理，Buff自身不负责判定何时消退。 ----------------------------------- ## **关于Buff效果系统的重构** ### 老框架 - 通过读取`buff_effect.csv`获取Buff对应的效果`dict[str, int | float]`，然后借助`data_analyzer.py`等模块，最终在构造乘区类`MultiplierData`时，转译成各属性、乘区加成 - 缺陷： - `data_analyzer.py`的业务逻辑基本就是字符串解释器，扩展性较差，而且维护、拓展非常烧脑，并且运行需要传入`Generator`来构造`list[Buff]`，耦合程度太高，难以测试。 - `MultiplierData`框架设计于立项初期，未考虑拓展和解耦，导致处理任何计算事件时都需要把全部属性、乘区都构造一遍，且生命周期极短，用完就扔，性能浪费严重， - `MultiplierData`没有设计供外部调用的接口，导致外部模块（例如`Buff.logic`或是`Character`）需要知道角色的动态属性时，就不得不调用大量参数就地构建一个新的`MultiplierData` ### 新框架 - 新框架将对整个系统（涉及到：`Buff`, `Character`, `Calculator`等多个模块）进行了重构，彻底实现“Buff生效”功能的解耦。 - 核心思路如下： 1. 将属性和乘区归还给`Character`对象，一同归入`Character`的还有计算属性和乘区的一些方法 2. 将Buff的效果对象化，并且在`Character`内部构造专门的容器用来存放效果对象，容器私有，外部只能访问`Character`提供的接口来获取所关心属性的实时加成 3. 在`buff_effect`池和`active_buff_list`池之间，构建自动化的同步流程，保证Buff新增时，加成池同步更新（但是需要考虑类似于席德强袭Buff这种“存在但不生效”的情况） - 切入点：`buff_effect`自己不知道是否应该加入效果池，所以，在`active_buff_list`更新时，`buff_effect`池子默认保持更新，而独立存在一个“去除Buff效果”或者是“使Buff存在但效果静默”的事件来执行这件事情——这属于一个Buff的额外效果，需要注册到事件树中。 4. 在`Calculator`中，对新架构进行适配（工作量略大） ### 相关重构细节如下（仅限于`buff_effect`以及角色属性、乘区相关） - `effect_base_class`相关（新增） - `effect_base_class`就是本轮重构中，为“Buff效果”设计的类，专门服务于更改属性、乘区的Buff效果而创建，至于Buff触发器，将直接通过事件树进行注册，而不走`effect_base_class`路径，也不会进入`Character`的加成池。 - 该对象的构造依赖数据库中记录的Buff效果json： ```json [ { "target_attribute": "固定攻击力", "value": 100, "element_type": [1,2,3], "skill_tag": ["1301_SNA_1", "1301_SNA_2"] }, { "target_attribute": "增伤", "value": 0.3 }, ] ``` - 根据以上格式的`json`数据，由`Buff`对象来负责构建`Buff.effect`对象。该对象会在Buff激活时，直接加入`BuffManager.buff_effect_pool`中，注意，一个Buff对应的effect的`json`字段可能有多个，此时我们需要构造多个`effect`对象，做到一个`effect`对象仅管理一种效果。考虑到Buff的效果被分为“属性值增减益”和“事件触发器两类”，所以，设计两个继承自`effect_base_class`的类，分别处理两种不同的业务。 - `bonus_effect_class(effect_base_class)`对象，具有属性和方法： - `value`：每一层Buff增幅的数值 - `target_attribute`：增幅的项目 - `apply_condition_list: list`：能够使Buff生效的额外条件，除`target_attribute`和`value`字段以外的其他字段，都会被视作生效条件约束，它们都会被编入`apply_judger.apply_condition_list`中 - `trigger_class(effect_base_class)`对象，具有属性和方法： - 前提条件：`json`字段中含有`trigger`参数，且对应值为True时，其他参数除`event_id`以外，全部失效（当然，最好要通过pydantic进行检测，这样可以尽早暴露JSON文件填写的问题） - `Character`相关 - 在`Character`下，构建一个新的`dynamic_attribute`（暂时名）类，与原有的`Statement`并列 - 将原本属于`MultiplierData`管理的动态属性和乘区占位符合并、转移到`dynamic_attribute`下 - 新增`attribute_calculator`对象，迁移位于`Calculator.py`中的大量计算属性、乘区的方法，业务逻辑上：通过调用`Character`原有的`Statement`方法获取静态面板，然后调用`buff_manager.bonus_applier`方法获取当前的动态加成，最后计算出实时属性。 - `Character`相关的新组件 - `buff_effect_selector`方法，接收核心参数`environment_profile`（事件画像），该参数由外部结构`event_router`抛出，根据该对象中记录的事件标签组合，从当前激活的Buff中筛选出适配的效果 - `bonus_applier`方法，该方法仅接受核心参数：`target_attribute`和`applied_buff_effect_list`，通过遍历`applied_buff_effect_list`，计算`target_attribute`的加成，返回给`Character.dynamic_attribute.attribute_calculator` - `active_buff_list`：Character级别的动态Buff列表，通过订阅Buff状态变更事件自动维护 - `bonus_pool`：Character级别的增益池对象，封装了效果池，以及效果池所需的CRUD方法。 - `buff_effect_data`：这是整个`bonus_pool`对象的核心，是一个手动搭建的二维数据结构，但不能`data_frame` > 需要二维数据结构但又不选择`data_frame`的原因： > - 要满足Buff的CRUD操作中，通过buff的id或是index来锁定对应buff_effect的需求， > - 要满足计算阶段，搜索某类属性加成时能够返回全部的适配buff_effect > - 而`data_frame`的内核其实是遍历，无法真正做到性能的节省。在buff系统中， 关于`buff_effect`的操作是非常频繁的，所以必须考虑性能问题。 - `add_buff_effect`：向`buff_effect_data`中新增Buff效果的方法 - `cancel_buff_effect`：向`buff_effect_data`中删除Buff效果的方法 - 其他方法按照业务需求进行拓展。 ## **buff_effect_data数据结构示意图** 以下是复合字典结构在ZSim中的应用示例： ### 多字典索引结构 | Buff名称或者id | 攻击力相关 | 生命值相关 | 增伤区相关 | 防御区相关 | |:---------|:-----------|:-----------|:-----------|:-----------| | **席德-围杀** | ✅ [+100] | ❌ | ✅ [+15%] | ❌ | | **席德-强袭** | ✅ [+200] | ❌ | ✅ [+25%] | ❌ | | **拂晓生花-普攻增伤** | ❌ | ❌ | ✅ [+10%] | ❌ | | **拂晓生花-四件套常驻** | ✅ [+50] | ✅ [+300] | ❌ | ❌ | | **机巧心种-暴击** | ✅ [+12%] | ❌ | ❌ | ❌ | | **机巧心种-电属性增伤** | ❌ | ❌ | ✅ [+20%] | ❌ | ### 对应的字典结构 ```python # 按Buff管理的字典 - 用于快速增删 _effects_by_buff = { 1001: [attack_effect_1001, damage_bonus_effect_1001], # 席德-围杀 1002: [attack_effect_1002, damage_bonus_effect_1002], # 席德-强袭 2001: [damage_bonus_effect_2001], # 拂晓生花-普攻增伤 # ... } # 按属性索引的字典 - 用于快速查询 _effects_by_attribute = { "攻击力": [attack_effect_1001, attack_effect_1002, attack_effect_2002, crit_effect_3001], "生命值": [hp_effect_2002], "增伤": [damage_bonus_effect_1001, damage_bonus_effect_1002, damage_bonus_effect_2001, damage_bonus_effect_3002], "防御": [], # 当前无防御相关Buff } ``` ================================================ FILE: docs/README_CN.md ================================================ # ZZZ模拟器 [English](../README.md) | 中文 ## 项目介绍 `ZZZ模拟器`是一款《绝区零》的伤害计算器。 本工具支持**全自动模拟**，无需手动设置技能释放序列（如需序列模式可以提issue） 您只需配置代理人装备，选择合适的APL（行动优先级列表），点击运行即可。 该工具提供友好的用户界面，可计算队伍整体伤害输出。基于预设的APL自动模拟队伍行动，触发buff，记录并分析结果，最终生成可视化图表报告。 ## 功能特性 - 基于队伍配置计算总伤害 - 生成可视化图表 - 提供各角色详细伤害数据 - 编辑代理人装备 - 编写APL代码 ## 安装指南 从发布页面下载最新打包源码或使用 `git clone` ### 安装UV（如未安装） 在任意终端中执行： ```bash # 使用pip安装： pip install uv ``` ```bash # macOS/Linux： curl -LsSf https://astral.sh/uv/install.sh | sh ``` ```bash # Windows11 24H2及以上： winget install --id=astral-sh.uv -e ``` ```bash # 旧版Windows： powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" ``` 或参考官方安装指南：[https://docs.astral.sh/uv/getting-started/installation/](https://docs.astral.sh/uv/getting-started/installation/) ### 安装并运行ZZZ模拟器 在项目目录中执行： ```bash uv sync uv run zsim run ``` ## 开发 ### 主要组件 1. **模拟引擎** - `zsim/simulator/` 中的核心逻辑处理战斗模拟 2. **Web API** - `zsim/api_src/` 中基于FastAPI的REST API，提供程序化访问 3. **Web UI** - `zsim/webui.py` 中基于Streamlit的界面以及 `electron-app/` 中的Vue.js + Electron桌面应用 4. **CLI** - 通过 `zsim/run.py` 的命令行接口 5. **数据库** - 基于SQLite的角色/敌人配置存储 6. **Electron应用** - 使用Vue.js和Electron构建的桌面应用，与FastAPI后端通信 ### 构建系统 项目使用基于 Make 的综合构建系统来管理开发、构建和发布流程。 #### 可用的 Make 目标 ```bash # 构建组件 make build # 完整构建（清理 + 后端 + Electron） make backend # 仅构建后端API make electron-build # 仅构建Electron桌面应用 # 开发 make dev # 启动前端开发服务器 make clean # 清理所有构建文件 make check # 检查依赖 # 工具 make help # 显示帮助信息 ``` ### 设置和安装 ```bash # 首先安装UV包管理器 uv sync # WebUI开发 uv run zsim run # FastAPI后端 uv run zsim api # Electron应用开发，还需安装Node.js依赖 cd electron-app pnpm install ``` ### 运行应用 #### 快速启动（推荐） ```bash # 一键启动开发服务器，包含前端和后端 cd electron-app pnpm dev ``` #### 单独组件 ```bash # Streamlit WebUI uv run zsim run # FastAPI后端 uv run zsim api # Electron桌面应用（生产构建） cd electron-app pnpm build ``` **注意**：`pnpm dev` 命令提供了最便捷的开发体验： - 自动启动Vue.js前端和FastAPI后端 - 将所有后端控制台输出转发到开发终端 - 提供前端热重载功能 - 启用完整的调试能力 ### 测试结构 - 单元测试位于 `tests/` 目录 - API测试位于 `tests/api/` - 测试固件在 `tests/conftest.py` 中定义 - 使用pytest并支持asyncio ```bash # 运行测试 uv run pytest # 运行测试并生成覆盖率报告 uv run pytest -v --cov=zsim --cov-report=html ``` ## 待办事项 详见[贡献指南](https://github.com/ZZZSimulator/ZSim/wiki/%E8%B4%A1%E7%8C%AE%E6%8C%87%E5%8D%97-Develop-Guide)获取最新开发计划。 ## 环境变量 ### FastAPI后端 - `ZSIM_DISABLE_ROUTES` - 设置为"1"以禁用API路由（默认：启用） - `ZSIM_IPC_MODE` - IPC通信模式："auto"、"uds"或"http"（默认："auto"） - `ZSIM_UDS_PATH` - 使用UDS模式时的socket文件路径（默认："/tmp/zsim_api.sock"） - `ZSIM_API_PORT` - API服务器端口，设置为0可自动选择端口（默认：0） - `ZSIM_API_HOST` - API服务器主机地址（默认："127.0.0.1"） ### IPC模式行为 - **auto**：在类Unix操作系统上使用uds，在Windows上使用http - **uds**：使用Unix域套接字进行本地通信（仅适用于类Unix系统） - **http**：使用HTTP/TCP进行通信（默认模式） ================================================ FILE: docs/RELEASE.md ================================================ # ZSim 版本发布指南 ## 🚀 发布方式 ### 1. GitHub Actions 自动发布（推荐） 使用 GitHub Actions 进行自动化版本发布： 1. 访问仓库的 Actions 页面 2. 选择 "Release" 工作流 3. 点击 "Run workflow" 4. 选择发布类型： - `patch` - 小版本更新 (1.0.0 → 1.0.1) - `minor` - 次版本更新 (1.0.0 → 1.1.0) - `major` - 主版本更新 (1.0.0 → 2.0.0) - `alpha` - Alpha 预发布 (1.0.0 → 1.0.1-alpha.0) - `beta` - Beta 预发布 (1.0.0 → 1.0.1-beta.0) 5. 选择是否创建草稿或预发布 6. 点击 "Run workflow" ### 2. 本地脚本发布 使用本地脚本进行发布： ```bash # 基本发布 ./scripts/release.sh patch # 预发布 ./scripts/release.sh alpha --prerelease # 草稿发布 ./scripts/release.sh minor --draft # 查看帮助 ./scripts/release.sh --help ``` ### 3. 手动发布 如果自动发布失败，可以手动进行： ```bash # 更新版本号 uv version --bump patch cd electron-app && pnpm version patch --no-git-tag-version && cd .. # 构建 make clean make backend make electron-build # 提交更改 git add pyproject.toml electron-app/package.json git commit -m "release: 版本发布 x.x.x" # 创建标签 git tag -a "vx.x.x" -m "Version x.x.x" # 推送 git push origin main git push origin vx.x.x ``` ## 📋 发布前检查清单 - [ ] 所有测试通过 - [ ] 代码格式化检查通过 - [ ] 类型检查通过 - [ ] 文档更新 - [ ] CHANGELOG 更新 - [ ] 版本号正确 - [ ] 构建测试通过 ## 📝 更新日志生成 ### 自动生成 ```bash # 生成当前版本的更新日志 ./scripts/changelog.py --update-changelog # 指定版本号 ./scripts/changelog.py --version 1.0.1 --update-changelog # 输出到文件 ./scripts/changelog.py --version 1.0.1 --output release_notes.md ``` ### 手动编辑 自动生成的更新日志可能需要手动调整，特别是： 1. 添加详细的更新说明 2. 修复分类错误 3. 添加重要提醒 4. 添加已知问题 ## 📦 发布内容 ### 自动发布的构建产物 - Windows: `ZSim-Setup-x.x.x.exe` - macOS: `ZSim-x.x.x.dmg` - Linux: `ZSim-x.x.x.AppImage` ### 发布说明模板 ```markdown ## 🎉 ZSim x.x.x Release ### 📦 版本信息 - 后端版本: x.x.x - 前端版本: x.x.x ### 🚀 更新内容 #### ✨ 新功能 - 功能1说明 - 功能2说明 #### 🐛 问题修复 - 问题1修复 - 问题2修复 #### 🔧 性能优化 - 优化1说明 - 优化2说明 ### 📋 安装说明 1. 下载对应平台的安装包 2. 运行安装程序 3. 启动 ZSim 应用 ### 📁 下载文件 - Windows: `ZSim-Setup-x.x.x.exe` - macOS: `ZSim-x.x.x.dmg` - Linux: `ZSim-x.x.x.AppImage` ### 🔄 升级说明 - 从旧版本升级时，建议先卸载旧版本 - 配置文件会自动保留 - 如遇问题，请删除配置文件后重新安装 ``` ## 🔧 版本号规范 遵循 [Semantic Versioning](https://semver.org/) 规范： - `MAJOR.MINOR.PATCH` - `1.0.0` - 主版本.次版本.修订版本 - `1.0.0-alpha.1` - Alpha 预发布 - `1.0.0-beta.1` - Beta 预发布 ### 版本号更新规则 - **PATCH**: 修复错误，向后兼容 - **MINOR**: 添加功能，向后兼容 - **MAJOR**: 破坏性更改，不向后兼容 ## 🚨 回滚发布 如果发布出现问题，需要回滚： ```bash # 删除远程标签 git push origin --delete vx.x.x # 删除本地标签 git tag -d vx.x.x # 回滚提交 git reset --hard HEAD~1 # 强制推送 git push origin main --force ``` ## 📊 发布后任务 1. **通知用户** - 在社区发布公告 - 更新应用商店描述 - 发送版本更新通知 2. **监控反馈** - 关注用户反馈 - 监控错误报告 - 收集功能建议 3. **文档更新** - 更新 README - 更新用户指南 - 更新 API 文档 4. **数据分析** - 分析下载量 - 统计用户活跃度 - 收集使用数据 ## 🔍 故障排除 ### 常见问题 1. **构建失败** - 检查依赖是否安装 - 确认环境变量设置 - 查看构建日志 2. **版本号冲突** - 确认版本号唯一性 - 检查标签是否存在 - 清理本地缓存 3. **权限问题** - 确认 GitHub Token 权限 - 检查仓库设置 - 验证用户权限 ### 获取帮助 - 查看构建日志：`Actions` → `Release` → 构建记录 - 检查仓库设置：`Settings` → `Actions` → `General` - 联系维护者：创建 Issue 或讨论 ## 📈 发布最佳实践 1. **定期发布** - 保持稳定的发布节奏 - 避免长时间不发布 - 建立发布周期 2. **质量保证** - 充分测试每个版本 - 确保向后兼容性 - 准备回滚方案 3. **用户沟通** - 提前预告重要更新 - 详细说明变更内容 - 及时响应用户反馈 4. **文档维护** - 保持文档与代码同步 - 提供清晰的升级指南 - 记录重要的变更历史 ================================================ FILE: docs/ReadMe.md ================================================ # 贡献指南 前往github查看详情： [develop guide](https://github.com/ZZZSimulator/ZSim/wiki/%E8%B4%A1%E7%8C%AE%E6%8C%87%E5%8D%97-Develop-Guide) ================================================ FILE: docs/ZZZSim_APL功能技术文档.md ================================================ # ZSim APL设计书 > #### 文档更新日期：2025.7.3 ## 0、前言 #### 本文档介绍了ZSim中APL模块的使用方法以及代码语法，以帮助每一位想要寻找更优解的ZSim使用者 > APL（Action Priority List），即战斗优先级序列，是ZZZ Simulator的核心功能，它可以使角色以我们设定好的优先级，完全自动的行动，配合全自动触发的Buff、属性异常、失衡、伤害计算等模块，组成了完整的模拟器。 > > 本工具仿照了《魔兽世界》的一款战斗模拟器（SimulationCraft） 中的APL功能设计。通过APL，可以对游戏角色的输出流程进行定制化管理，并且，由程序以100%的完成度进行执行。 > > 我们认为，一份足够优秀、严谨的APL代码，是完全可以复刻玩家的玩法构思和输出思路的，因为构造APL代码的本质就是对输出逻辑的逆向解构。 > >
>
---
## 1、ZSim中APL模块的运作原理
ZSim的APL模块每次运行时，都会从APL脚本的第一行开始，逐行检验其条件部分，直到找到某一行的所有条件全部通过，就将这一行所指向的技能ID输出给下一步程序。每一行APL代码都只能指向一个动作，但是限制条件可以是多个，同一个动作的限制条件之间用 `|`分隔符进行隔离，这些条件之间都是“与”关系（不要纠结为什么没有用 `&`）。
当前版本，如果激活某动作的条件之间存在“或”关系，则应写多行APL代码。
APL系统详细介绍
>通常，针对同一个角色或是队伍的手法讨论，只能基于玩家的感觉来进行，对于“怎么打比较合适”的手法细节讨论，往往得不出一个最终的结论。即使我们能够借助第三方的游戏计算器，让局部总伤计算更加精确，但也最多只能做到局部精确。某个手法或是某种输出策略对于全局战斗的影响，依旧是难以计算和模拟的。
>所以，模拟仿真计算器以及APL脚本应运而生。二者结合，就可以真正实现不同策略之间的公平比较，比如：某角色有能量和豆子两种资源，那么到底是优先打能量资源，还是优先打豆子资源呢？通过APL的控制，我们可以设计两套手法，一套永远先打能量，一套永远先打豆子。APL就好像一个水平超高的玩家，它会清晰、稳定地执行我们设计好的既定手法。
>最终，我们从模拟结果上，可以看到两套手法方案被百分百执行时的输出水平，从而找出其中最优的输出策略。这样的仿真思路，在很多游戏中都能见到，比如Simc、Gscim（原神的模拟仿真软件）等。
>本模拟器（ZZZSim） 的APL功能正是仿照Simc的APL运行逻辑写的。但是在具体的运行上有一些不同。语法上也针对游戏特色进行了一些优化和改动。
>后续开发方向
目前，程序只支持“非门”和“与门”，暂不具备解析“或门”的能力。不过，该功能将会是APL功能拓展的首个目标，因为当APL脚本代码涉及到多条件中的多个“或”逻辑时，现有的脚本语法会让APL代码变得非常臃肿冗杂，所以，解析“或”逻辑的功能可以说是迫在眉睫。
| 参数 | 类型 | 备注 |
|---|---|---|
# |
注释 | 用于解释该行APL的作用，不是必须的。 |
1091 |
动作角色 | 在ZSim内部，雅的数字ID为1091 |
action+= |
动作类型 | action类型，即"主动动作类型"，可以简单理解为"打出一个技能" |
1091_SNA_3 |
动作ID | 技能ID，或填写wait代表什么都不做。 |
attribute.1091:special_resource==6 |
条件单元 | 控制了本行APL是否执行的限制条件 |
但请注意，这些带后缀的特殊动作类型尚处于开发阶段，开发团队尚不能保证其稳定性和正确性， 不同策略在面对合轴、QTE、大招等技能抢队时可能会做出完全不同的表现，其中，APL的大部分行为都是合理且符合预期的，但是也一定会存在一些Bug导致APL在策略冲突的情况下做出错误决策。 总之，我们团队会持续关注、开发这一功能，直至它彻底稳定。
| 动作类型 | 稳定度 | 解释 |
|---|---|---|
action+= |
高 | 最普通类型的APL |
action.no_swap_cancel+= |
中 | 避免合轴策略，即哪怕时间和其他条件均满足，可以进行合轴，当前APL也不会放行，除非上一个动作彻底结束 |
action.atk_response_positive+= |
低 | “积极地进行进攻响应”：即角色会在怪物红、黄光亮起后的最早时间进行响应（闪避或是弹刀） |
action.atk_response_balance+= |
“平衡地进行进攻响应”：即角色会在怪物红、黄光亮起后的最晚时间进行响应（闪避或是弹刀） |
| 符号 | 含义 | 示例 | 实例解释 |
|---|---|---|---|
| |
分隔符，用于分割不同的条件单元。虽然|符号自身具有“或”的语义，但是在APL中，它只作为分隔符使用，被它分隔的各个条件单元之间是“与”关系。 |
条件单元1|条件单元2 | 需要同时满足条件1和条件2 |
! |
“非”，即表达条件的反义。由于APL语法中比较符必须存在（包括!=），实际使用量不大 | !action.after: index==1091_SNA_3 |
上一个技能的ID不是1091_SNA_3 |
→ |
复杂数据集中的子项名称（特殊字符，中文输入法输入"You"打出） | attribute.1251:special_state→醉花月云转可用次数>=0 |
青衣的特殊状态中的醉花月云转可用次数≥0 |
==以及 !=，与其对应的检索值为：True 和 False ；
2、数值比较：此类条件比较支持6种类数值比较符：>、<、==、!=、>=、<=，与之对应的检索值类型为：int 、float
3、None比较：此类条件比较符只有两种：==以及 !=，与其对应的检索值为：None
4、字符比较：此类条件比较符只有两种：==以及 !=，与其对应的值检索类型为：str
---
- #### 检索内容
APL语法中的检索内容种类繁多，其中的绝大部分都只要填入表中对应的字符即可，只有以下几种检索内容，我会使用指定单次进行替代：
1、buff_index ：该检索内容被使用于 Buff类条件 中，表示填入一个Buff的索引，也是Buff的名字，通常，Buff的index是一长串带有中文的字符，比如 “Buff-角色-丽娜-核心被动-穿透率”，顺带一提，Zsim中的Buff名都是这种格式，非常直观，光看名字大概就能知道Buff的作用。
2、skill_tag ：该检索内容被使用于 action 类条件中，指的是某技能的具体ID，如ZSim中，雅的满蓄力普攻的ID为“1091_SNA_3”。
---
> 接下来，让我们正式开始。
>
> ### ▶5.1 动作类条件——action
>
> action 类条件的检索目标可以分为两类：检索角色或者检索全队。
>
> | 条件类型 | >分隔符 | >检索目标 | >含义 | >开发现状 | >
action |
> . |
> CID |
> 检索角色CID的动作栈，检查其过去动作 |
> 可用 | >
team |
> 检索全队的动作栈，检查全队过去的动作 | >暂不可用 | >
> >
>
>
> action 类型的全参数详解如下表：
>
> 角色动作栈与全队动作栈的区别
> >在Zsim中，角色和全队都有各自的动作栈。每位角色都将记住自己最近的3个动作，而全队则将记住最近的5个动作。
> >注意：这里的动作不仅包括主动动作，也包括一些自动触发的被动动作，比如板机的协同攻击、耀佳音的震音、薇薇安的落羽生花等，这一点非常重要，这关系到角色能否顺利实现玩家预设的连招。
> >由于ZSim是支持合轴操作的，所以，在个人动作栈中相邻的两个动作，在全队动作栈中很可能不相邻——比如角色在相邻的两段平A之间，触发了扳机的协同攻击，那么在全队动作栈中，就会出现 平A 扳机协同攻击 平A的情况。
> >所以如果你希望雅在自己的第三段平A后衔接强化E，则应该让APL直接检索雅的个人动作栈，而非全队动作栈。
> >| 检索目标 | >分隔符 | >检索内容 | >比较类型 | >解释 | >
| CID | >: |
> strict_linked_after |
> 字符比较 | >强衔接判定，语义为：“严格衔接于……动作后”， > 此类APL条件单元的放行不仅需要skill_tag符合要求，还需要上一个动作刚好结束 |
>
lenient_linked_after |
> 弱衔接判定，语义为：“衔接于……动作后”， > 此类APL条件单元只需要skill_tag符合就会放行 |
> |||
positive_linked_after |
> 积极衔接判定，语义为：“尝试衔接于……动作后”， > 本类APL与 lenient_linked_after功能基本相同，但是语义上更好理解。 |
> |||
is_performing |
> 正在释放判定，语义为：“角色正在释放……动作”， > | |||
first_action |
> 布尔值比较 | >首个动作判定，语义为：“角色是否没有释放过任何技能？” |
> ||
during_parry |
> 招架交互判定，语义为：“角色当前是否正处于招架状态？ （招架——招架成功——被击退）” |
> |||
assault_aid_enable |
> 突击支援可用，语义为：“角色是否满足使用突击支援的前置条件？” （成功招架一次攻击并且被击退状态已经消退） |
> |||
| team （弃用） |
> skill_tag | >字符比较 | >team的skill_tag属性本来用于检查“全队的上一个技能”，但由于全队动作栈会受到合轴以及各种协同攻击插队的影响，导致“上一个技能”的检索结果经常在短时间内频繁更替，这会严重误导APL的判定，让本该放行的技能阻塞，或者让本该被跳过的技能执行。所以在古早的开发版本中，APL模块的action.team:skill_tag==xxxx语句就随着合轴功能的更新而被废弃了 | >
| 检索目标 | >分隔符 | >检索内容 | >分隔符 | >嵌套结构键值链 | >比较类型 | >解释 | >
enemy |
> : |
> stun |
> 无分隔符 | >无键值链 | >布尔值比较 | >敌人是否处于失衡状态 | >
stun_pct |
> 数值比较 | >敌人当前的失衡百分比 | >||||
QTE_triggered_times |
> 数值比较 | >敌人已经激发过几次连携技 | >||||
QTE_activation_available |
> 布尔值比较 | >是否处于彩色失衡阶段 | >||||
QTE_triggerable_times |
> 数值比较 | >敌人能被连携的最大次数 | >||||
single_qte |
> None比较 | >是否激发连携并进入连携待应答状态 | >||||
is_under_anomaly |
> 布尔值比较 | >敌人是否处于异常状态 | >||||
is_shock |
> 敌人是否处于感电状态 | >|||||
is_burn |
> 敌人是否处于灼烧状态 | >|||||
is_assault |
> 敌人是否处于畏缩状态 | >|||||
is_frostbite |
> 敌人是否处于霜寒状态 | >|||||
is_frost_frostbite |
> 敌人是否处于烈霜霜寒状态 | >|||||
is_corruption |
> 敌人是否处于侵蚀状态 | >|||||
anomaly_pct_0 |
> 数值比较 | >敌人当前物理属性积蓄百分比 | >||||
anomaly_pct_1 |
> 敌人当前火属性积蓄百分比 | >|||||
anomaly_pct_2 |
> 敌人当前冰属性积蓄百分比 | >|||||
anomaly_pct_3 |
> 敌人当前电属性积蓄百分比 | >|||||
anomaly_pct_4 |
> 敌人当前以太属性积蓄百分比 | >|||||
anomaly_pct_5 |
> 敌人当前烈霜属性积蓄百分比 | >|||||
anomaly_pct_6 |
> 敌人当前玄墨属性积蓄百分比 | >
>
>
>
>
>
> enemy部分的参数展示完毕，接下来是角色部分。status类的条件也可以检索角色的属性，只需要在检索目标处填入角色对应的CID即可。
>
> 查看示例
>| > | 示范1 | >示范2 | >示范3 | >
| APL含义 | ># 敌人是否处于失衡状态 | ># 敌人的电属性异常积蓄百分比是否大于等于80% | ># 敌人已经被激发了连携技，并且连携技整等待应答 | >
| APL代码 | >status.enemy:stun==True |
> status.enemy:anomaly_pct_3>=0.8 |
> status.enemy:single_qte!=None |
>
| 检索目标 | >分隔符 | >检索内容 | >分隔符 | >嵌套结构键值链 | >比较类型 | >解释 | >
CID |
> : |
> on_field |
> 无分隔符 | >无键值链 | >布尔值比较 | >被检索角色是否在前台 | >
char_available |
> 被检索角色是否可用 | >|||||
quick_assist_available |
> 被检索角色的快速支援是否亮起 | >|||||
assist_waiting_for_anwser |
> 被检索角色是否处于快速支援即将亮起但还未亮起的状态1 | >|||||
lasting_node_tag |
> 字符比较 | >检索 目标角色连续、重复释放技能的skill_tag， 若该角色最近没有连续、重复释放技能，那么就检索最近一次释放的技能 |
> ||||
lasting_node_tick |
> 数值比较 | >检索目标角色连续、重复释放技能的持续时间（单位：tick） | >||||
repeat_times |
> 检索目标角色连续、重复释放技能的次数 | >
| 检索目标 | >分隔符 | >检索内容 | >分隔符 | >嵌套结构键值链 | >比较类型 | >解释 | >
CID |
> : |
> energy |
> 无分隔符 | >无键值链 | >数值比较 | >检索 目标角色当前的能量 | >
cinema |
> 检索 目标角色当前的影画数值 | >|||||
decibel |
> 检索 目标角色当前的喧响值 | >|||||
special_resource_type |
> 字符比较 | >检索 目标角色当前的特殊资源的名称 | >||||
special_resource |
> 数值比较/布尔值比较 | >检索 目标角色当前的特殊资源的数值 | >
| CID | >角色姓名 | >special_resource_type（str） |
> special_resource（int / bool / float） |
> 数值类型 | >取值范围 | >
| 1361 | >扳机 | >决意值 | >决意值数值 | >float | >（0画）0~100 （1画及以上）0~125 |
>
| 1331 | >薇薇安 | >护羽 | >护羽数值 | >int | >0~6 | >
| 1221 | >柳 | >由于柳没有特殊资源（架势状态通过special_state属性检索），所以柳的 special_resource和special_resource_type返回的是None |
> None | >||
| 1311 | >耀嘉音 | >咏叹华彩 | >咏叹华彩状态 | >bool | >True / False | >
| 1191 | >艾莲 | >急冻充能 | >急冻充能点数 | >int | >0~6 | >
| 1091 | >雅 | >落霜 | >落霜点数 | >0~6 | >|
| 1041 | >11号 | >火力镇压 | >火力镇压层数 | >0~8 | >|
| 1241 | >朱鸢 | >强化霰弹 | >强化霰弹层数 | >0~9 | >|
| 1131 | >苍角 | >涡流 | >涡流层数 | >0~3 | >|
| 1261 | >简 | >狂热心流 | >狂热心流值 | >float | >0~100 | >
| 1161 | >莱特 | >士气 | >士气值 | >0~100 | >|
| 1251 | >青衣 | >闪络电压 | >闪络电压值 | >0~100 | >|
| 1381 | >零号·安比 | >银星层数 | >银星层数 | >0~3 | >|
| 1371 | >仪玄 | >闪能 | >闪能点数 | >0~120 | >|
| 0000 | >> | > | > | > | > |
| 检索目标 | >分隔符 | >检索内容 | >分隔符 | >嵌套结构键值链 | >比较类型 | >解释 | >
| 1361（扳机） | >: |
> special_state |
> → | >狙击姿态 | >布尔值比较 | >检索 扳机当前是否处于狙击姿态 | >
| 1331 （薇薇安） |
> 护羽数量 | >数值比较 | >检索 薇薇安当前的护羽数量 | >|||
| 飞羽数量 | >检索 薇薇安当前的飞羽数量 | >|||||
| 裙裾浮游 | >布尔值比较 | >检索 薇薇安当前是否处于裙裾浮游状态 | >||||
| 淑女礼仪 | >检索 薇薇安当前是否处于淑女礼仪状态 | >|||||
| 1221 （柳） |
> 当前架势 | >布尔值比较 | >检索 柳的当前架势，True为上弦，False为下弦 | >|||
| 森罗万象状态 | >检索 柳当前的森罗万象状态的激活情况 | >|||||
| 1311 （耀嘉音） |
> 咏叹华彩 | >布尔值比较 | >检索 耀嘉音当前是否处于咏叹华彩状态 | >|||
| 1191 （艾莲） |
> 该角色没有可以被检索的特殊状态 | >|||||
| 1091 （雅） |
> 该角色没有可以被检索的特殊状态 | >|||||
| 1041 （11号） |
> 该角色没有可以被检索的特殊状态 | >|||||
| 1241 （朱鸢） |
> 该角色没有可以被检索的特殊状态 | >|||||
| 1131 （苍角） |
> 该角色没有可以被检索的特殊状态 | >|||||
| 1261 （简） |
> 狂热心流 | >数值比较 | >检索 简当前的狂热心流数值 | >|||
| 狂热状态 | >布尔值比较 | >检索 简当前是否处于狂热状态 | >||||
| 萨霍夫跳剩余次数 | >数值比较 | >检索 简当前的萨霍夫跳的剩余可用次数 | >||||
| 1161 （莱特） |
> 士气 | >数值比较 | >检索 莱特当前的士气值 | >|||
| 1251 （青衣） |
> 闪络电压 | >数值比较 | >检索 青衣当前的闪络电压值 | >|||
| 醉话月云转可用次数 | >检索 青衣当前的醉花月云转突刺攻击的剩余可用次数 | >|||||
| 闪络状态 | >布尔值比较 | >检索 青衣当前是否处于闪络状态 | >||||
| 1381 （零号·安比） |
> 白雷(内部功能) | >布尔值比较 | >检索 大安比的白雷触发器的开合状态 | >|||
| 雷殛(内部功能) | >检索 大安比的雷殛触发器的开合状态 | >|||||
| 6画状态(内部功能) | >检索 大安比的6画触发器的开合状态 | >|||||
| 1画状态(内部功能) | >检索 大安比的1画触发器的开合状态 | >|||||
| E连击 | >检索 大安比是否处于连续释放E技能的状态 | >|||||
| 满层 | >检索 大安比的银星标记是否叠满 | >|||||
| 白雷连击次数 | >数值比较 | >检索 大安比的白雷连击次数 | >||||
| 2画_电鸣 | >检索 大安比2画的电鸣的剩余可用次数 | >|||||
| 6画_白雷次数 | >检索 大安比6画的白雷计数器 | >|||||
| 1画_白雷次数 | >检索 大安比1画的白雷计数器 | >|||||
| 1307 （仪玄） |
> 术法值 | >数值比较 | >检索 仪玄当前的术法值 | >|||
| 玄墨值 | >检索 仪玄当前的玄墨值 | >|||||
| 聚墨点数 | >检索 仪玄当前的聚墨点数 | >|||||
| 调息层数 | >检索 仪玄当前的调息层数 | >|||||
>
>
>
>
> ---
>
> ### ▶5.4 增减益效果类条件——buff
>
> APL还支持 buff 类条件，这类条件只有3个功能，针对Buff存在状态、 持续时间、当前层数的检查，语法如下：
>
> 查看示例
>| > | 示范1 | >示范2 | >示范3 | >
| APL含义 | ># 青衣的醉话月云转突刺攻击剩余次数大于1次 | ># 简不处于狂热状态下 | ># 大安比正处于E连击状态下 | >
| APL代码 | >attribute.1251:special_state→醉花月云转可用次数>1 |
> attribute.1261:special_state→狂热状态==False |
> attribute.1381:special_state→E连击==True |
>
| 检索目标 | >分隔符 | >检索内容 | >分隔符 | >嵌套结构键值链 | >比较类型 | >解释 | >
| CID enemy |
> : |
> exist |
> → | >buff名 xxx |
> 布尔值比较 | >检索 Buff（xxx）是否存在于角色（CID）或enemy身上 | >
duration |
> 数值比较 | >检索 角色（CID）或enemy身上的Buff（xxx）的持续时间 | >||||
count |
> 检索 角色（CID）或enemy身上 Buff（xxx）的层数 | >
>
>
>
>
> ---
>
> ### ▶5.5 特殊类条件——special
>
> 当前，special类条件还处于开发阶段，表现并不稳定，请谨慎使用。
> 查看示例
>| > | 示范1 | >示范2 | >
| APL含义 | ># 雅身上存在丽娜的穿透率Buff | ># 柳身上存在耀嘉音的攻击力Buff | >
| APL代码 | >buff.1091:exist→Buff-角色-丽娜-核心被动-穿透率==True | >buff.1221:Buff-角色-耀佳音-核心被动-攻击力==True | >
| 检索目标 | >分隔符 | >检索内容 | >嵌套结构键值链 | >比较类型 | >解释 | >
| 无要求 一般写preload_data |
> : |
> operating_char |
> 无 | >数值比较 | >检索当前正在进行主动操作的角色的CID （扳机协同攻击这种并非由玩家直接指令引发的动作就不属于主动操作，同时，若当前tick无角色主动操作，APL会主动获取当前处于前台的角色的CID） |
>
is_attacking |
> 布尔值比较 | >检索 当前tick的战斗中，是否存在激活的进攻事件 | >
>>
>>
> ```python
> #豆子相差很远时，也优先开大
> 1091|action+=|1091_Q|attribute.1091:special_resource<4|attribute.1091:decibel==3000|status.enemy:stun==True
> ```
>
> 和上一句的大招APL相比，这一句改变了豆子的判定，并且取消了能量的判定。只有满足以下条件（可以简单概括为：要么豆子数量不对，要么能量值不对），APL才的执行才会来到第四行（不满足的条件为 橙色）：
>
> 情况1：满喧响（默认） | 豆子∈\(3, 6\]| 能量足够
>
> 情况2：满喧响（默认） | 豆子∈[0, 3] | 能量不够
>
> 情况3：满喧响（默认） | 豆子∈[0, 3] | 能量足够
>
> 而本条APL针对的恰好就是 情况2 ，即在有没能量，且大招不会导致豆子溢出时开大。
> ```python
> #泄能逻辑
> 1091|action+=|1091_E_EX_A_1|status.enemy:stun==True|attribute.1091:energy>=40|attribute.1091:special_resource<6
> ```
>
> 这里展示的APL是雅在失衡期的泄能逻辑。如果你全局检查目前已经展示的5行APL，你就不难发现本行APL中藏着一个无效条件——能量判定。从上面的三种情况的列举可以看出，能够进入到这一行的APL，均是能量足够的情况。所以能量判定在这一行是无效的。
>
> 这也意味着，这一行APL的作用，就是“无脑泄蓝”，哪怕此时喧响值足够，也是优先打强化E。（很明显，这个逻辑是不对的，在实战中我们面对豆子不满、且有能量、有大的情况，往往会先进行豆子判断。如果开大豆子不溢出，那就优先开大，如果开大豆子溢出，那就优先打E。）
>
> 根据上述推理，这一行的APL实际上可以优化为以下两行来执行。
>
> ```python
> 1091|action+=|1091_E_EX_A_1|status.enemy:stun==True|attribute.1091:special_resource<6|attribute.1091:special_resource>4
> 1091|action+=|1091_Q|status.enemy:stun==True|attribute.1091:special_resource<3
> ```
>
> 这两行APL如果调换先后顺序，实际上起到的效果是完全相同的。这也是APL的一个核心特点：位于分类讨论末端的几种情况的APL先后顺序不影响实际效果，因为它们本质上是同优先级的APL。
## 7、结尾
通过本文档，我们详细介绍了ZSim中APL模块的设计原理、语法规则以及实际应用示例。
APL作为ZSim的核心功能之一，能够帮助玩家精确模拟角色的输出逻辑，优化战斗策略。希望本文档能够为开发者和使用者提供清晰的指导，帮助大家更好地理解和使用APL功能。
#### 后续计划
- 编写一个可视化的修改APL代码的前端工具
- 开发APL语法检查器
- 支持“或”逻辑：当前版本的APL仅支持“与”逻辑，未来我们将优先开发“或”逻辑的支持，以简化复杂条件的编写。
- 扩展条件类型：我们计划增加更多的条件类型，以支持更复杂的战斗场景和角色机制。
- 优化性能：进一步提升APL的解析和执行效率，确保在大规模模拟中的稳定性。
#### 反馈与支持
如果您在使用过程中遇到任何问题，或有任何建议和反馈，欢迎通过以下方式联系我们：
邮箱：<1012399286@qq.com>
感谢您对ZSim的支持，我们将持续改进和优化，为您提供更好的模拟体验。
================================================
FILE: docs/数据库录入指南.md
================================================
# **ZZZ Simulator 技能数据库录入指南**
## **前言**
> **Buff数据库** 是 **ZZZ Simulator** 中最主要也是最重要的数据库，整个数据结构参考了 ``*WOW早期版本的Buff数据库*``[^1] ，为了实现Buff的精准、自动触发，我们设计了更加适合《绝区零》需求的Buff *``触发逻辑``*[^2] ，在这套逻辑中，我们将Buff的触发规则分解成若干参数，并且根据参数比对和脚本来实现Buff触发的自动判断。
>
> 1:WOW的角色技能多，装备多，所以Buff量很大，所以，想要每一个动作都遍历整个Buff库是不现实的。针对这一需求，WOW的开发团队设计了“Buff链”结构，即“BuffA触发时，会读取‘后续触发ID’，并且根据其中的ID来触发后续的其他Buff”；“Buff链”结构可以在一定程度上简化初次数据的录入，更多时候Buff的触发只依赖Buff ID，而不依赖其他参数。但是也导致了数据库中存在着海量无实际效果的“触发器”，这些空Buff会大幅增加后续的维护成本。
>
> 2:在ZZZ Calculator中，我们并未采用WOW的Buff数据库的链式结构，而是采用了遍历判定的底层逻辑。在初始化时，程序会从总的Buff库中挑选出所有“可能用到的Buff”组建一个临时的Buff库，并且不断遍历这个Buff库，来实现所有Buff的触发判定。这么做的好处是，所有Buff的触发行为都独立，当某个Buff的触发出现异常，就可以直接找到数据库中对应位置进行debug，而不用排查一众指向该Buff的触发器，但是这个结构也有它的劣势，那就是性能上的开销更大。
>
> 3:我们并未完全放弃WOW式的链式结构，《绝区零》中部分复杂Buff仍然需要这种链式结构的帮助，所以我们简单复刻了符合该结构的参数解析，从而在必要时使用链式结构来处理部分复杂Buff
---
## **数据库构成**
| 文件名 | 作用 |
| :-----------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `飞书表格` | Buff数据库的预录制平台，我们团队往往会首先在飞书表格中进行Buff的解构、设计以及参数的录入，再由Buff功能负责人虎皮 负责将数据录入到数据库中，并进行debug和测试 |
| `激活判断.csv` | 控制Buff是否参与计算，同时记录Buff的判定、生效、结束逻辑，以及持续时间、判定节点等；参数多、复杂度高，是数据录入压力最大的表格。 |
| `触发判断.csv` | 记录Buff的触发规则，参数多，但是目前用到的参数很少，参数数值的确定也十分简单、明确 |
| `Buff_effect.csv` | 记录Buff的效果，完全不需要考虑逻辑，只需要考虑 |
> ***飞书表格链接：展开说明
>>由于APL的执行顺序是从上到下，所以，在执行到这一行之前，前两行是一定没有通过的。前面我们介绍过，导致本行APL出错的条件集为：满豆且满喧响。那么这种场景，会在第二行APL被拦下来。上面展示的第二行APL，就是让雅在有穿透率Buff的时候，优先泄豆。
>>有的读者可能又注意到了新的问题。“那如果身上恰好没有Buff，且满豆，那APL的执行不就漏到第三行了吗？”
>>放心，这个情况也是不会出现的。因为在失衡期，身上没有Buff的情况会被第一行APL拦下来。
>>总之，如果APL的运行来到了第三行，那么就说明当前起码是：有穿透率Buff且不满豆的状态，也就是说，我们补写的那个条件判定，在第三行的位置上，是永远不会起到作用的。
>>可见，APL的优先级思维要求大家以全新的视角来拆分、看待自己的游戏逻辑。
>>
>
> 上图即为仿真程序在一个tick（模拟实战中的1帧）内的Buff判定以及触发流程。根据Buff的自身逻辑，分为1、2两轮。两轮的结构与原理大致相同。
>
> 根据Buff的复杂度，可以将其分为“简单Buff”与“复杂Buff”两类，前者的触发行为可以总结为一下三种：
>
>
> 接下来，我将向你介绍各阶段的具体作用以及需要用到的参数及其含义。
> - **初始化**
>
> 这个阶段的主要功能，就是从Buff库中挑选那些“可能会用到的Buff”，并把它们加入到本次模拟所需要的*``临时容器``*[^4]里。主要判定依据来自于队伍的初始化信息（角色自身、音擎、驱动盘套装等）。
>
> 该阶段需要检测 **`激活判断.csv`** 中的以下参数：
>
> | 参数 | 数据类型 | 含义 |
> | :----------------: | :------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
> | `BuffName` | str | Buff的中文索引，唯一值 |
> | `is_weapon` | bool | 该Buff来自于音擎 |
> | `is_debuff` | bool | 该Buff是debuff，决定了Buff是否被添加给enemy。 |
> | `is_cinema` | bool | 该Buff来自于影画 |
> | `from` | str | Buff源（角色名、音擎名、驱动盘套装名，enemy） |
> | `refinement` | int | 精炼等级，该参数是多用途的，默认值为0，当Buff为命座Buff时，该参数为命座数值；当Buff为音擎Buff时，该参数为音擎精炼数值；同时，极少数的复杂Buff也会借用该参数来记录一些特殊数据 |
> | `add_Buff_to` | str | Buff会加给谁：该参数是一个四位二进制数（虽然设计初衷是字符串，但是在飞书中，它会被默认处理为正常十进制的数字，类似于“0001”这样的会显示成“1”，此时正常进行记录即可，在程序读取前会进行统一的格式化，并且补齐缺少的“0”），从左到右四个数位分别代表了：自己、下一位角色、上一位角色、敌人 |
> | `backend_active` | bool | 是否后台激活。程序默认的底层逻辑是“只检测前台角色的Buff”，想要前台角色的某些动作，触发一些后台角色的Buff，那就需要更改此参数为True；举例：“任意队友释放……时，……”，这种Buff就是可以在后台被激活的，所以此参数需要填写True。 |
>
> 这个阶段的运行结果将直接决定接下来整个模拟进程中的全部Buff，如果参数填写错误，那么可能导致本不应该激活的Buff意外激活，或是本应激活的Buff没有激活。``*（比如 `is_cinema`与 `refinement`参数填写错误，可能导致高影画Buff在低影画被触发）*``
> - **第一轮Buff判定介绍 & 主要Buff类型说明**
>
> 这个阶段处理的主要是常规类的Buff，共分为判定、触发两个大板块。
>
> 按照游戏逻辑，Buff判定理应处于伤害计算发生之前，否则当前tick新触发的Buff将无法影响当前tick的伤害计算。最简单的Buff，只要通过参数比对就能判断是否符合触发条件，而复杂一些Buff则需要通过脚本来进行判定。判定板块主要依托于判定函数，其运行结果为一个布尔值。
>
> 总的来说，拆解后的Buff判定规则是比较复杂的，几种主要规则之间都存在交集。为了准确表达这些主要判定规则之间的关系，同时尽量简明地z指出它们的主控参数，接下来我将结合韦恩图和``*表格*``[^5] 来进行说明。
>
> 
>
> | | **更新条件** | **解释** | **主控参数** | **关键词/句** |
> | :---------: | ------------------ | ---------------------------------------------------------------- | ----------------------------------- | ---------------------------------------- |
> | **A** | 动作开始 | 在动作的开始标签处（start标签，动作开始的第1帧）发生更新 | `prejudge` | 发动XX时…… |
> | **B** | 动作命中 | 在动作的命中标签处（hit标签）发生更新 | `hit_increase` | ……XX命中时…… |
> | **C** | 动作结束 | 在动作的结束标签处（end标签，最后一个hit的后1帧）发生更新 | `endjudge` | ……XX结束时…… |
> | **D** | 无持续时间 | maxduration=0[^6] | `maxduration` | ……XX技能的…… |
> | E* | 开始+命中 | 在动作开始时触发，在动作命中时更新 | `prejudge` `hit_increase` | 发动XX时……，每命中一次…… | > | F* | 命中+无持续 | 动作命中时更新，但Buff只增幅当前动作，所以动作结束时Buff就会结束 | `maxduration` `hit_increase` | ……XX技能伤害增加，且每命中一次叠层…… | > | G* | 开始+无持续 | 动作开始时触发，动作结束时候结束， | `prejudge`
`maxduration` | ……XX技能的伤害增加…… | > - **`激活判断.csv`全参数介绍** > > 明确了各大类Buff以及它们的主控参数后，我将给出 **`激活判断.csv`** 中所有的参数及其说明。重复出现过的参数，我将从简说明。 > > | 参数 | 数据类型 | ``阶段与功能 | 说明 | > | ------------------------- | -------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | > | `BuffName` | str | ``全阶段`` | Buff名，唯一值 | > | `is_weapon` | bool | ``初始化`` | 来源于武器 | > | `is_debuff` | bool | ``全阶段`` | 是debuff | > | `is_additional_ability` | bool | ``初始化`` | 来源于组队被动 | > | `is_cinema` | bool | ``初始化`` | 来源于影画 | > | `from` | str | ``全阶段`` | Buff源（角色名、装备等） | > | `exist` | bool | ``无`` | ``空参数，暂时用不到`` | > | `description` | str | ``无`` | ``Buff描述，或者其他说明，大多为官方文案的简化版`` | > | `durationtype` | bool | ``无`` | ``是否具有持续时间，基本和maxduration是同一个意思，目前程序中用不到这个参数，但是需要正确填写`` | > | `maxduration` | int | ``判定`` | 最大持续时间，单位是tick（帧） | > | `maxcount` | int | ``判定`` | 最大层数 | > | `incrementalstep` | int | ``判定`` | 自增步长，即每次叠层时，增加多少层。 | > | `prejudge` | bool | ``判定`` | 动作开始时触发 | > | `endjudge` | bool | ``判定`` | 动作结束时触发 | > | `freshtype` | bool | ``无`` | ``重复触发是否能够刷新持续时间，和后面的 hitincrease 参数有重合，该参数暂时用不到，但需正常填写。`` | > | `alltime` | bool | ``判定`` | 始终触发。该参数为True时，将跳过一切判定直接输出True，将彻底改变Buff的判定、触发、退出行为，总体来说相当暴力、笨重，可控性极差，理论上只要是存在不触发的情况的Buff，该参数都应为False，除非Buff是真的全程触发，该参数才为True。 | > | `hitincrease` | bool | ``判定`` | 重复触发是否能够刷新持续时间 | > | `increaseCD` | int | ``判定`` | 内置CD，Buff只要不说明，那么就默认为0。单位是tick（帧） | > | `readyto_increase` | bool | ``无`` | ``空参数，暂时用不到`` | > | `simple_judge_logic` | bool | ``判定`` | 是否是简单判定逻辑，当Buff触发的判定逻辑比较复杂，通过参数控制无法精准判定Buff触发时，该参数改为False | > | `simple_start_logic` | bool | ``判定`` | 开始标签处的启动行为是否简单；当Buff属于start更新类型（上表中的A类Buff），且触发时的启动行为较为复杂[^7]的，该参数应改为False | > | `simple_end_logic` | bool | ``判定`` | 结束标签处的启动行为是否简单；当Buff属于end更新类型（上表中的C类Buff），且触发时的启动行为较为复杂的，该参数应改为False | > | `simple_hit_logic` | bool | ``判定`` | 命中标签处的启动行为是否简单；当Buff属于hit更新类型（上表中的B类Buff），且触发时的启动行为较为复杂的，该参数应改为False | > | `simple_effect_logic` | bool | ``判定`` | Buff的启动不依赖于动作的开始、命中、结束标签，而是在另外的时间点来实现触发和启动的，该参数为False。注意，本参数为False时，`simple_judge_logic`参数一般也为False | > | `simple_exit_logic` | bool | ``判定`` | Buff的退出逻辑是否简单；正常情况下，Buff的退出（或者叫消失）仅需要检测持续时间，但是部分Buff的退出逻辑是复杂的（如冲击力小于XX点时，Buff消失），此时，本参数为False | > | `refinement` | int | ``灵活`` | 精炼等级，或者命座，或者其他参数。灵活参数，默认值为0 | > | `add_buff_to` | str | ``判定`` | Buff加给谁，二进制四位数。 | > | `schedule_judge` | bool | ``判定`` | 是否是第二轮判定的Buff（对第二轮判定有疑问的，请参考本章节开头给出的流程图，里面有1、2阶段的详细说明和对比） | > | `individual_settled` | bool | ``判定`` | Buff层数是否独立判定（硫磺石like） | > | `backend_acitve` | bool | ``判定`` | 是否在后台也要保持触发检测 | > - **`触发判断.csv`的作用** > > `激活判断.csv`规定了Buff的基本属性与触发行为，而 `触发判断.csv`则规定了Buff触发所需要的具体条件。由于游戏中大部分的Buff的触发都依赖于角色的主动动作，所以，`触发判断.csv`中的参数大部分都与技能参数相同。所以，为了填写 `触发判断.csv`中的数据，我们需要将触发条件解构成参数，这就要求我们对技能参数的结构也有所了解。 > > 为此，我制作了Buff判定的原理示意图，来帮助大家理解Buff系统是如何利用通用参数对Buff的触发结果进行判定的。 > >
>
> 从上图不难看出，Buff的触发条个数往往是比较少的，而技能的特定参数只要等于触发条件，那么就可以让技能通过判断。
>
> 注意：较为复杂的Buff我们通常都诉诸脚本来实现触发判定，所以这类Buff在`触发判断.csv`中往往不需要填写任何内容（就算填写了也会因为 `激活判断.csv`中的 `simple_judge_logic` 参数为 `False`而直接运行脚本，参数比对这部分逻辑是不会运行的）
> - **`触发判断.csv`全参数介绍**
>
> > - **关于分隔符**
> >
> > 和`激活判断.csv`不同的是，`触发判断.csv`往往需要在一个参数中输入多个互为“或”关系的条件（由于技能的各个参数都明确对应一个数值，所以Buff的触发条件是不需要考虑“与”关系的，只需要考虑“或”关系即可）。我们用 `|`符号 *``（shift+回车上面那个键）``* 来表示“或”，前后没有空格。
> >
>
> | 参数 | 数据 类型 | 说明 & 使用频率 |
> | :-----------------------------: | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
> | `BuffName` | str | 与 `激活判断.csv`一样，该参数为表中的唯一值，是Buff的名字。 |
> | `id` | str | 这里的id指的是技能的id，该参数可以将Buff的触发范围缩小到指定技能 |
> | `OfficialName` | str | ``技能的官方全名*（比如终结技：天霸横空烈轰）*，一般用不到`` |
> | `From` | str | ``技能来源，即技能所对应的角色名，一般用不到`` |
> | `SpConsumption` | float | 技能的能量消耗，``基本上只有在Buff条件为“技能的能耗=X”时才能使用，有这个需求的Buff可以说是十分罕见[^8]，绝大部分情况下该参数是用不到的`` |
> | `SpRecovery_hit` | float | 技能的命中回能，``和上一条相比，这一条的使用频率更低。别说是绝区零了，我玩了那么多的游戏，我都找不出一个以“命中回能等于N点”为触发条件的Buff，所以这个条件一般也是空的`` |
> | `Sp_Threshold` | float | 技能的能耗门槛[^9]，``同上，用的很少，一般为空`` |
> | `FeverRecovery` | float | 技能的喧响值回复，``一般为空，原因与能耗那一条类似，不过多赘述`` |
> | `ElementAbnormalAccumulation` | int | 技能的异常积蓄属性类型，大多数时候，该参数与下面的 `ElementType`参数等价，并且在限定元素类型时，通常使用 `ElementType`参数，而非本参数，具体解释详见 ``**附表3**``，``非特殊情况[^10]，该参数为空`` |
> | `SkillType` | int | 技能类型。这里的类型指的是技能大类，具体解释见``**附表1**`` |
> | `TriggerBuffLevel` | int | 是最常用的技能分类！这个可以理解为技能类型的细分，几乎每一种技能都有单独的参数。具体解释详见``**附表2**`` |
> | `ElementType` | int | 技能的伤害属性，详细解释见``**附表3**`` |
> | `TimeCost` | int | 技能耗时，单位Tick（也就是帧），``该参数不常用，一般为空`` |
> | `HitNumber` | int | 技能命中次数，``不常用，一般为空`` |
> | `DmgRelated_Attributes` | str | 造成伤害所依赖的参数[^11]，``现在还用不到，为空`` |
> | `StunRelated_Attributes` | str | 计算失衡值所依赖的参数[^11]，``现在还用不到，为空`` |
> | `Interruption_Resistance` | float | 技能的抗打断系数，``抗打断模块与Buff判定模块基本不互动，一般情况下为空`` |
>
> ---
>
>> `` **附表1：SkillType参数解释**``
>>
>> `SkillType`主要指的是技能大类，可以简单理解为角色在技能加点时的分类。
>>
>> | 参数数值 | 含义 |
>> | :------: | ------------------------------------------------------------------------------------------------ |
>> | `0` | 普通攻击，以及其他一切包含普攻标签的内容（比如部分角色6画中常见的附加伤害） |
>> | `1` | 特殊技，包括E和强化E以及其他一切包含E标签的技能（比如耀佳音的耗能音簇） |
>> | `2` | 闪避技，包括闪避、闪避反击 |
>> | `3` | 终结技，包括连携技、大招两个技能， |
>> | `4` | 核心被动，这一条暂时没用，因为目前角色的核心被动都是Buff，并没有角色的某个主动技能属于这一标签。 |
>> | `5` | 支援技，包括招架/回避支援、突击支援、快速支援（原名：受击支援） |
>>
>
> ---
>
>> `` **附表2：TriggerBuffLevel参数解释**``
>>
>> `TriggerBuffLevel`，可以说是最常用参数之一了，Buff库中接近60%数量的Buff需要依靠这一参数来进行判定。可以理解为技能种类的细分，和 `SkillType`作用是一样的。
>>
>> 在使用时，应根据技能判定的需求，在`TriggerBuffLevel`和 `SkillType`中灵活选择。
>>
>> | 参数数值 | 含义 |
>> | :------: | -------------------------- |
>> | `0` | 普通攻击 |
>> | `1` | 特殊级（普通E） |
>> | `2` | 强化E |
>> | `3` | 冲刺攻击 |
>> | `4` | 闪避反击 |
>> | `5` | 连携技 |
>> | `6` | 终结技 |
>> | `7` | 快速支援（原名：受击支援） |
>> | `8` | 招架/回避支援 |
>> | `9` | 突击支援 |
>>
>
> ---
>
>> ``**附表3：ElementType & ElementAbnormalAccumulation 参数解释**``
>>
>> `ElementType`记录了技能的伤害属性，注意！是伤害属性！在讲解 `ElementAbnormalAccumulation`参数时，已经解释过了为何要把积蓄属性和伤害属性分开，这里就不重复说明了。
>>
>> | 参数数值 | 在 `ElementType`中的含义 | 在 `ElementAbnormalAccumulation`中的含义 |
>> | :------: | -------------------------- | ------------------------------------------ |
>> | `0` | 物理 | 物理积蓄（如果无属性积蓄则为空） |
>> | `1` | 火 | 火积蓄 |
>> | `2` | 冰 | 冰积蓄 |
>> | `3` | 电 | 电积蓄 |
>> | `4` | 以太 | 以太积蓄 |
>> | `5` | 烈霜（随星见雅新增） | 烈霜积蓄（随星见雅新增） |
>>
>> -------时效性说明-------
>> 更新日期：2025.2.15
>> 游戏版本：1.5--伊芙琳
>> 更新人：虎皮
>>
最后，为保证数据录入工作顺利，请务必按本文前面给出的工作流程执行录入~感谢您的配合。
虎皮，写于2025.2.15
[^4]: 在程序中，该容器是EXIST_Buff_DICT
[^5]: 表格中，带 * 的项目意味着在数据库中不常见，只有非常少量的Buff才会涉及。
[^6]: 这里并不是指Buff完全没有持续时间，在程序中，只增幅某种技能的Buff（比如下两次普通攻击的伤害增加），虽然理论上持续时间是0，在数据库中，对应的maxduration参数也是0，但是在程序实际运行过程中，这些Buff会被等效看做是“持续时间为动作时间”的Buff来处理。
[^7]: 复杂的触发行为可以理解为，用 `maxduration`、`maxcount`、`incrementalstep`等参数无法实现精确控制的触发行为，比如：某Buff触发时，会根据当前属性值来计算出层数（莱特），亦或是某Buff更新时，会根据另一个Buff的层数来计算自己的层数（青衣专武）等等，这些都属于“复杂触发行为”。
[^8]: 能耗参数几乎用不到的原因是：参数对比模块只会在简单判定逻辑中执行，而这部分的程序只能判断**能耗等于填入数值**的情况。游戏中的Buff，触发条件与能耗有关的本就不多，且它们的触发条件都为“能耗>或者
{/* 侧栏 */}
);
};
export default App;
================================================
FILE: electron-app/src/components/LanguageSwitch.tsx
================================================
import { FC } from "react";
import { useLanguage } from '../hooks/useLanguage';
interface LanguageSwitchProps {
className?: string;
}
export const LanguageSwitch: FC
{/* 侧边顶部 */}
{/* 模块 */}
ZSim
{asideMenuList.map(menu => (
{/* 侧边底部 */}
setActiveMenu(menu.key)}
>
))}
{menu.label}
{/* 模块.1 */}
{/* 模块.3 */}
{asideMenuMap.get(activeMenu)}
{/* 模块.2 */}
API 状态: {apiStatus}
{apiResponse && typeof apiResponse === 'object' && 'message' in apiResponse ? (
后端: {(apiResponse as { message?: string }).message || '未知'}
) : null}
创建会话
重新测试API
setLanguage('zh')}
>
中文
setLanguage('en')}
>
English
{general.get("title", "无标题")}
👤 作者：{general.get("author", "佚名")}
📅 创建时间：{general.get("create_time", "无")}
🔄 上次修改：{general.get("latest_change_time", "无")}
攻击力: {statement.get('ATK', 0):.2f}
",
unsafe_allow_html=True,
)
st.markdown(
f"暴击率: {statement.get('CRIT_rate', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"暴击伤害: {statement.get('CRIT_damage', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"生命值: {statement.get('HP', 0):.2f}
",
unsafe_allow_html=True,
)
st.markdown(
f"防御力: {statement.get('DEF', 0):.2f}
",
unsafe_allow_html=True,
)
st.markdown(
f"穿透率: {statement.get('PEN_ratio', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"穿透值: {statement.get('PEN_numeric', 0):.2f}
",
unsafe_allow_html=True,
)
st.markdown(
f"能量自动回复: {statement.get('sp_regen', 0):.2f}
",
unsafe_allow_html=True,
)
st.markdown(
f"冲击力: {statement.get('IMP', 0):.2f}
",
unsafe_allow_html=True,
)
with col_right:
st.markdown(
f"冰属性伤害: {statement.get('ICE_DMG_bonus', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"火属性伤害: {statement.get('FIRE_DMG_bonus', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"物理属性伤害: {statement.get('PHY_DMG_bonus', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"以太属性伤害: {statement.get('ETHER_DMG_bonus', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"电属性伤害: {statement.get('ELECTRIC_DMG_bonus', 0):.2%}
",
unsafe_allow_html=True,
)
st.markdown(
f"异常精通: {statement.get('AP', 0):.2f}
",
unsafe_allow_html=True,
)
st.markdown(
f"异常掌控: {statement.get('AM', 0):.2f}
",
unsafe_allow_html=True,
)
if use_columns:
cols = st.columns(len(characters))
for i, character in enumerate(characters):
with cols[i]:
_display_panel(character)
else:
for character in characters:
_display_panel(character)
@st.dialog("角色面板")
def dialog_character_panels(name_box: list[str]) -> None:
# 默认使用分列显示
display_character_panels(name_box, use_columns=False)
================================================
FILE: zsim/lib_webui/process_dmg_result.py
================================================
import json
import os
import plotly.express as px
import polars as pl
import streamlit as st
from zsim.define import ANOMALY_MAPPING
from zsim.sim_progress.Character.skill_class import lookup_name_or_cid
from .constants import SKILL_TAG_MAPPING, element_mapping, results_dir
def _load_dmg_data(rid: int | str) -> pl.DataFrame | None:
"""加载指定运行ID的伤害数据CSV文件。
Args:
rid (int): 运行ID。
Returns:
Optional[pd.DataFrame]: 加载的伤害数据DataFrame，如果文件未找到则返回None。
"""
csv_file_path = os.path.join(results_dir, str(rid), "damage.csv")
try:
lf = pl.scan_csv(csv_file_path)
# 去除列名中的特殊字符
schema_names = lf.collect_schema().names()
lf = lf.rename(
{col: col.replace("\r", "").replace("\n", "").strip() for col in schema_names}
)
return lf.collect()
except FileNotFoundError:
st.error(f"未找到文件：{csv_file_path}")
return None
def prepare_line_chart_data(dmg_result_df: pl.DataFrame) -> dict[str, pl.DataFrame]:
"""准备用于绘制伤害与失衡曲线图的数据。
Args:
dmg_result_df (pl.DataFrame): 原始伤害数据。
Returns:
dict[str, Any]: 包含处理后数据的字典，用于绘制折线图。
- 'line_chart_df': 包含时间、伤害、DPS、失衡值、失衡效率的DataFrame。
"""
processed_df = dmg_result_df.clone()
# 计算DPS
processed_df = processed_df.with_columns(
(pl.col("dmg_expect").cum_sum() / pl.col("tick") * 60).alias("dps")
)
# 处理失衡值
if "失衡状态" in processed_df.columns:
processed_df = processed_df.with_columns(
pl.when(pl.col("失衡状态")).then(0).otherwise(pl.col("stun")).alias("stun")
)
# 计算失衡效率
first_stun_row = processed_df.filter(pl.col("失衡状态") == True).head(1) # noqa: E712
if len(first_stun_row) > 0:
first_stun_tick = first_stun_row["tick"][0]
before_stun = processed_df.filter(pl.col("tick") <= first_stun_tick)
after_stun = processed_df.filter(pl.col("tick") > first_stun_tick)
before_stun = before_stun.with_columns(
(pl.col("stun").cum_sum() / pl.col("tick") * 60).alias("stun_efficiency")
)
after_stun = after_stun.with_columns(pl.lit(None).alias("stun_efficiency"))
processed_df = pl.concat([before_stun, after_stun])
else:
processed_df = processed_df.with_columns(
(pl.col("stun").cum_sum() / pl.col("tick") * 60).alias("stun_efficiency")
)
return {"line_chart_df": processed_df}
def draw_line_chart(chart_data: dict[str, pl.DataFrame]) -> None:
"""绘制伤害与失衡曲线图。
Args:
chart_data (Dict[str, pl.DataFrame]): 包含绘制图表所需数据的字典。
"""
df = chart_data["line_chart_df"]
with st.expander("伤害与失衡曲线："):
# 时间-伤害分布
st.subheader("时间-伤害分布")
fig_dmg = px.line(
df,
x="tick",
y=["dmg_expect", "dmg_crit"],
labels={
"tick": "时间（帧数）",
"value": "伤害值",
"variable": "数据类型",
"dmg_expect": "期望伤害",
"dmg_crit": "暴击伤害",
},
)
st.plotly_chart(fig_dmg)
# 时间-DPS分布
st.subheader("时间-DPS分布")
fig_dps = px.line(
df,
x="tick",
y="dps",
labels={"tick": "时间（帧数）", "dps": "DPS"},
)
st.plotly_chart(fig_dps)
# 时间-失衡值分布
st.subheader("时间-失衡值分布")
fig_stun = px.line(
df,
x="tick",
y="stun",
labels={"tick": "时间（帧数）", "stun": "失衡值"},
)
st.plotly_chart(fig_stun)
# 时间-失衡效率分布
st.subheader("时间-失衡效率分布")
fig_stun_eff = px.line(
df,
x="tick",
y="stun_efficiency",
labels={"tick": "时间（帧数）", "stun_efficiency": "失衡效率（每秒）"},
)
st.plotly_chart(fig_stun_eff)
def _get_cn_skill_tag(skill_tag: str) -> str:
"""根据技能标签获取技能中文名。
Args:
skill_tag (str): 技能标签。
Returns:
str: 技能中文名。
"""
return SKILL_TAG_MAPPING.get(skill_tag, skill_tag)
def sort_df_by_UUID(dmg_result_df: pl.DataFrame) -> pl.DataFrame:
"""按UUID对伤害数据进行分组和聚合。
Args:
dmg_result_df (pl.DataFrame): 原始伤害数据。
Returns:
pl.DataFrame: 按UUID聚合后的数据，包含每个UUID的总伤害、总失衡、总积蓄等信息。
Raises:
ValueError: 如果DataFrame缺少必要的列。
"""
required_columns = [
"skill_tag",
"dmg_expect",
"stun",
"buildup",
"UUID",
"is_anomaly",
]
for col in required_columns:
if col not in dmg_result_df.columns or dmg_result_df[col].is_null().all():
raise ValueError(f"DataFrame 中缺少有效的列: {col}")
result_data = []
all_UUID = dmg_result_df["UUID"].unique().to_list()
for UUID in all_UUID:
same_UUID_rows = dmg_result_df.filter(pl.col("UUID") == UUID)
dmg_expect_sum = same_UUID_rows["dmg_expect"].fill_null(0).sum()
stun_sum = same_UUID_rows["stun"].fill_null(0).sum()
buildup_sum = same_UUID_rows["buildup"].fill_null(0).sum()
skill_tags = same_UUID_rows["skill_tag"].drop_nulls()
skill_tag = skill_tags[0] if len(skill_tags) > 0 else None
is_anomaly = same_UUID_rows["is_anomaly"][0]
element_types = same_UUID_rows["element_type"].drop_nulls()
element_type = element_types[0] if len(element_types) > 0 else None
cid: int | str | None = None
name: str | None = None
skill_cn_name: str | None = None
if skill_tag:
cid_str = skill_tag[0:4]
skill_cn_name = _get_cn_skill_tag(skill_tag) # 获取技能中文名
try:
name, cid_lookup = lookup_name_or_cid(cid=cid_str)
cid = cid_lookup
except ValueError:
name = skill_tag # 如果查找失败，使用skill_tag作为名字
cid = None
else:
skill_cn_name = "Unknown" # 如果没有skill_tag，则设为Unknown
result_data.append(
{
"UUID": UUID,
"name": name,
"element_type": element_type,
"is_anomaly": is_anomaly,
"cid": cid,
"skill_tag": skill_tag,
"skill_cn_name": skill_cn_name, # 添加技能中文名
"dmg_expect_sum": dmg_expect_sum,
"stun_sum": stun_sum,
"buildup_sum": buildup_sum,
}
)
return pl.DataFrame(result_data)
def prepare_char_chart_data(uuid_df: pl.DataFrame) -> dict[str, pl.DataFrame]:
"""准备用于绘制角色参与度分布图的数据。
Args:
uuid_df (pl.DataFrame): 按UUID聚合后的伤害数据。
Returns:
Dict[str, Any]: 包含绘制饼图所需数据的字典。
- 'char_dmg_df': 按角色分组的伤害总和。
- 'char_stun_df': 按角色分组的失衡总和。
- 'char_skill_dmg_df': 按角色和技能标签分组的伤害总和。
- 'char_element_df': 按角色和元素类型分组的积蓄总和。
"""
# 各伤害来源占比
char_dmg_df = (
uuid_df.filter(pl.col("dmg_expect_sum") > 0)
.group_by(["name", "is_anomaly"])
.agg(pl.col("dmg_expect_sum").sum())
)
# 角色失衡占比
char_stun_df = (
uuid_df.filter(pl.col("stun_sum") > 0).group_by("name").agg(pl.col("stun_sum").sum())
)
# 角色技能输出占比
filtered_skill_df = uuid_df.filter(pl.col("cid").is_not_null())
char_skill_dmg_df = filtered_skill_df.group_by(["name", "skill_cn_name"]).agg(
[
pl.col("dmg_expect_sum").sum(),
pl.col("buildup_sum").sum(),
pl.col("stun_sum").sum(),
]
)
# 角色属性积蓄占比
filtered_buildup_df = uuid_df.filter(pl.col("buildup_sum") > 0)
char_element_df = filtered_buildup_df.group_by(["name", "element_type"]).agg(
pl.col("buildup_sum").sum()
)
return {
"char_dmg_df": char_dmg_df,
"char_stun_df": char_stun_df,
"char_skill_dmg_df": char_skill_dmg_df,
"char_element_df": char_element_df,
}
def draw_char_chart(chart_data: dict[str, pl.DataFrame]) -> None:
"""绘制角色参与度分布图。
Args:
chart_data (Dict[str, Any]): 包含绘制图表所需数据的字典。
"""
char_dmg_df = chart_data["char_dmg_df"]
char_stun_df = chart_data["char_stun_df"]
char_skill_dmg_df = chart_data["char_skill_dmg_df"]
char_element_df = chart_data["char_element_df"]
with st.expander("角色参与度分布情况："):
cols1 = st.columns(2)
# 角色伤害占比分布
with cols1[0]:
st.subheader("队伍伤害来源占比")
if len(char_dmg_df) > 0:
fig_dmg_pie = px.pie(
char_dmg_df,
names="name",
values="dmg_expect_sum",
labels={"name": "来源", "dmg_expect_sum": "期望伤害总和"},
)
st.plotly_chart(fig_dmg_pie)
else:
st.info("没有非零伤害数据可供显示")
# 角色失衡占比分布
with cols1[1]:
st.subheader("队伍失衡来源占比")
if len(char_stun_df) > 0:
fig_stun_pie = px.pie(
char_stun_df,
names="name",
values="stun_sum",
labels={"name": "来源", "stun_sum": "失衡值总和"},
)
st.plotly_chart(fig_stun_pie)
else:
st.info("没有非零失衡值数据可供显示")
# 每个角色的各技能输出占比分布
st.subheader("各角色技能输出占比")
unique_names = char_skill_dmg_df["name"].unique()
if len(unique_names) > 0:
cols2 = st.columns(len(unique_names))
col_index = 0
for name in char_skill_dmg_df["name"].unique().to_list():
group = char_skill_dmg_df.filter(pl.col("name") == name)
with cols2[col_index]:
st.caption(f"{name}")
fig_skill_pie = px.pie(
group,
names="skill_cn_name",
values="dmg_expect_sum",
labels={
"skill_cn_name": "技能名称",
"dmg_expect_sum": "期望伤害总和",
},
)
st.plotly_chart(fig_skill_pie)
col_index += 1
else:
st.info("没有角色技能伤害数据可供显示")
# 每个角色各技能的异常积蓄占比
st.subheader("各角色技能异常积蓄占比")
unique_names = char_skill_dmg_df["name"].unique()
if len(unique_names) > 0:
cols2 = st.columns(len(unique_names))
col_index = 0
for name in char_skill_dmg_df["name"].unique().to_list():
group = char_skill_dmg_df.filter(pl.col("name") == name)
with cols2[col_index]:
st.caption(f"{name}")
fig_skill_ano_pie = px.pie(
group,
names="skill_cn_name",
values="buildup_sum",
labels={
"skill_cn_name": "技能名称",
"buildup_sum": "异常值总和",
},
)
st.plotly_chart(fig_skill_ano_pie)
col_index += 1
else:
st.info("没有角色技能异常数据可供显示")
# 每个角色各技能的失衡值占比
st.subheader("各角色技能失衡值占比")
unique_names = char_skill_dmg_df["name"].unique()
if len(unique_names) > 0:
cols2 = st.columns(len(unique_names))
col_index = 0
for name in char_skill_dmg_df["name"].unique().to_list():
group = char_skill_dmg_df.filter(pl.col("name") == name)
with cols2[col_index]:
st.caption(f"{name}")
fig_skill_stun_pie = px.pie(
group,
names="skill_cn_name",
values="stun_sum",
labels={
"skill_cn_name": "技能名称",
"stun_sum": "失衡值总和",
},
)
st.plotly_chart(fig_skill_stun_pie)
col_index += 1
else:
st.info("没有角色技能失衡数据可供显示")
# 每个角色各属性的积蓄占比
st.subheader("各属性积蓄来源占比")
unique_elements = char_element_df["element_type"].unique()
if len(unique_elements) > 0:
cols3 = st.columns(len(unique_elements))
col_index = 0
for element in unique_elements:
element_df = char_element_df.filter(pl.col("element_type") == element)
element_name = element_mapping.get(element, element) # 获取元素中文名
with cols3[col_index]:
st.caption(f"{element_name}")
fig_buildup_pie = px.pie(
element_df,
names="name",
values="buildup_sum",
labels={"name": "角色", "buildup_sum": "积蓄值总和"},
)
st.plotly_chart(fig_buildup_pie)
col_index += 1
else:
st.info("没有属性积蓄数据可供显示")
def _find_consecutive_true_ranges(df: pl.DataFrame, column: str) -> list[tuple[int, int]]:
"""查找DataFrame列中连续为True的范围。
Args:
df (pl.DataFrame): 输入的DataFrame，需要包含 'tick' 列。
column (str): 要查找的布尔列名。
Returns:
list[tuple[int, int]]: 一个包含 (开始tick, 结束tick) 元组的列表。
"""
ranges = []
start = None
# 获取tick列和指定列的值
ticks = df["tick"].to_list()
values = df[column].to_list()
for i, (tick, value) in enumerate(zip(ticks, values, strict=False)):
if value:
if start is None:
start = tick
else:
if start is not None:
# 结束tick应该是上一个为True的tick
prev_tick = ticks[i - 1] if i > 0 else start
ranges.append((start, prev_tick))
start = None
# 处理最后一个区间（如果存在）
if start is not None:
ranges.append((start, ticks[-1]))
return ranges
def prepare_timeline_data(dmg_result_df: pl.DataFrame) -> pl.DataFrame | None:
"""准备用于绘制异常状态时间线的数据。
Args:
dmg_result_df (pl.DataFrame): 原始伤害数据。
Returns:
Optional[pl.DataFrame]: 用于绘制Gantt图的DataFrame，如果缺少列或无数据则返回None。
"""
required_columns = [
"冻结",
"霜寒",
"畏缩",
"感电",
"灼烧",
"侵蚀",
"烈霜霜寒",
"tick",
]
missing_cols = [col for col in required_columns if col not in dmg_result_df.columns]
if missing_cols:
st.error(f"输入数据缺少必要的列: {missing_cols}")
return None
columns_to_check = ["冻结", "霜寒", "畏缩", "感电", "灼烧", "侵蚀", "烈霜霜寒"]
gantt_data = []
for col in columns_to_check:
if col in dmg_result_df.columns:
ranges = _find_consecutive_true_ranges(dmg_result_df, col)
for start, end in ranges:
gantt_data.append({"Task": col, "Start": start, "Finish": end})
if not gantt_data:
return None
gantt_df = pl.DataFrame(gantt_data)
gantt_df = gantt_df.with_columns(
(pl.col("Finish") - pl.col("Start") + 1).alias("Duration")
) # 持续时间包含首尾
return gantt_df
def draw_char_timeline(gantt_df: pl.DataFrame | None) -> None:
"""绘制异常状态时间线（Gantt图）。
Args:
gantt_df: 用于绘制Gantt图的数据，如果为None则不绘制。
"""
with st.expander("异常时间线："):
if gantt_df is not None and len(gantt_df) > 0:
fig_timeline = px.bar(
gantt_df,
x="Duration",
y="Task",
base="Start",
orientation="h",
labels={
"Start": "开始时间(帧)",
"Duration": "持续时间(帧)",
"Task": "状态类型",
},
height=250,
)
st.plotly_chart(fig_timeline)
else:
st.warning("没有找到任何连续的状态数据")
def calculate_and_save_anomaly_attribution(
rid: int | str, char_dmg_df: pl.DataFrame, char_element_df: pl.DataFrame
) -> None:
"""计算并保存异常伤害归因。
Args:
rid (int): 运行ID。
char_dmg_df (pd.DataFrame): 角色直接伤害数据。
char_element_df (pd.DataFrame): 角色元素积蓄数据。
"""
output_path = f"{results_dir}/{rid}/damage_attribution.json"
# 检查文件是否已存在
if os.path.exists(output_path):
return
# 计算每种元素类型的异常总伤害
anomaly_name_list = list(ANOMALY_MAPPING.values()) + ["极性紊乱", "异放"]
anomaly_damage_totals = {element: 0 for element in anomaly_name_list}
for anomaly_name in anomaly_name_list:
if anomaly_name in char_dmg_df["name"].to_list():
filtered_df = char_dmg_df.filter(pl.col("name") == anomaly_name)
for row in filtered_df.iter_rows(named=True):
anomaly_damage_totals[anomaly_name] += row["dmg_expect_sum"]
# 初始化一个包含所有角色的字典
all_characters = set(char_dmg_df.filter(~pl.col("is_anomaly"))["name"].to_list()).union(
set(char_element_df["name"])
)
# 初始化角色伤害数据
attribution_data: dict[str, dict[str, float]] = {
name: {"direct_damage": 0, "anomaly_damage": 0} for name in all_characters
}
# 处理只打出直伤的角色
for row in char_dmg_df.filter(~pl.col("is_anomaly")).iter_rows(named=True):
name = row["name"]
direct_damage = row["dmg_expect_sum"]
attribution_data[name]["direct_damage"] = direct_damage
# 分配异常伤害到角色
for row in char_element_df.iter_rows(named=True):
name = row["name"]
element_type = row["element_type"]
buildup_sum = row["buildup_sum"]
anomaly_name = ANOMALY_MAPPING[element_type]
total_anomaly_damage = anomaly_damage_totals[anomaly_name]
# 计算角色的异常伤害归因
if total_anomaly_damage > 0:
element_total = char_element_df.filter(pl.col("element_type") == element_type)[
"buildup_sum"
].sum()
anomaly_damage_attribution = (buildup_sum / element_total) * total_anomaly_damage
else:
anomaly_damage_attribution = 0
# 更新角色的异常伤害
attribution_data[name]["anomaly_damage"] += anomaly_damage_attribution
# 处理极性紊乱和异放
for anomaly_name in ["极性紊乱", "异放"]:
total_anomaly_damage = anomaly_damage_totals.get(anomaly_name, 0)
if total_anomaly_damage > 0:
if anomaly_name == "极性紊乱":
for key in attribution_data:
if key == "柳":
attribution_data[key]["anomaly_damage"] += total_anomaly_damage
if anomaly_name == "异放":
for key in attribution_data:
if key == "薇薇安":
attribution_data[key]["anomaly_damage"] += total_anomaly_damage
with open(output_path, "w", encoding="utf-8") as f:
json.dump(attribution_data, f, ensure_ascii=False, indent=4)
def prepare_dmg_data_and_cache(
rid: int | str,
) -> dict[str, pl.DataFrame | dict[str, pl.DataFrame]] | None:
"""准备并缓存伤害分析所需的数据。
Args:
rid (int): 运行ID。
Returns:
Optional[dict[str, pl.DataFrame]]: 包含预处理后的数据的字典，
如果没有数据则返回None。
"""
dmg_result_df = _load_dmg_data(rid)
if dmg_result_df is None:
return None
uuid_df = sort_df_by_UUID(dmg_result_df)
char_chart_data = prepare_char_chart_data(uuid_df)
# st.write(char_chart_data)
calculate_and_save_anomaly_attribution(
int(rid) if isinstance(rid, int) else rid,
char_chart_data["char_dmg_df"],
char_chart_data["char_element_df"],
)
return {
"dmg_result_df": dmg_result_df,
"char_dmg_df": char_chart_data["char_dmg_df"],
"uuid_df": uuid_df,
"char_chart_data": char_chart_data,
}
def show_dmg_result(rid: int | str) -> None:
"""处理并显示指定运行ID的伤害分析结果。
Args:
rid (int): 运行ID。
"""
st.subheader(f"{rid} 的伤害数据分析")
prepared_data_dict = prepare_dmg_data_and_cache(rid)
if prepared_data_dict is None:
return
uuid_df = prepared_data_dict["uuid_df"]
char_chart_data = prepared_data_dict["char_chart_data"]
dmg_result_df = prepared_data_dict["dmg_result_df"]
if dmg_result_df is None:
return
with st.expander("原始数据："):
st.dataframe(dmg_result_df)
with st.expander("按UUID排序后的数据："):
st.dataframe(uuid_df)
# 准备并绘制折线图
line_chart_data = prepare_line_chart_data(dmg_result_df) # type: ignore
draw_line_chart(line_chart_data)
# 准备并绘制角色分布图
draw_char_chart(char_chart_data) # type: ignore
# 准备并绘制时间线图
timeline_data = prepare_timeline_data(dmg_result_df) # type: ignore
draw_char_timeline(timeline_data)
================================================
FILE: zsim/lib_webui/process_parallel_data.py
================================================
"""
这个模块应该在WebUI被启用后依然存在，可以转移到api_src中。
"""
import asyncio
import json
import os
from typing import Any
import aiofiles
import plotly.graph_objects as go
import streamlit as st
from zsim.define import results_dir
from zsim.lib_webui.process_buff_result import show_buff_result
from zsim.lib_webui.process_dmg_result import show_dmg_result
from zsim.utils.process_buff_result import prepare_buff_data_and_cache
from zsim.utils.process_dmg_result import prepare_dmg_data_and_cache
from .constants import stats_trans_mapping
reversed_stats_trans_mapping = {v: k for k, v in stats_trans_mapping.items()}
def judge_parallel_result(rid: int | str) -> bool:
"""判断对应的rid是否为并行模式。
Args:
rid (int): 运行ID。
Returns:
bool: 如果是并行模式，则返回True；否则返回False。
"""
result_dir = os.path.join(results_dir, str(rid))
if not os.path.isdir(result_dir):
return False
parallel_config_path = os.path.join(result_dir, ".parallel_config.json")
if not os.path.exists(parallel_config_path):
return False
try:
with open(parallel_config_path, "r", encoding="utf-8") as f:
parallel_config: dict = json.load(f)
if not parallel_config.get("enabled", False):
return False
except (json.JSONDecodeError, IOError):
# 如果文件读取或解析失败，也视为非并行模式
return False
# 检查是否存在至少一个包含 sub.parallel_config.json 的子目录
for item in os.listdir(result_dir):
sub_dir_path = os.path.join(result_dir, item)
if os.path.isdir(sub_dir_path):
sub_config_path = os.path.join(sub_dir_path, "sub.parallel_config.json")
if os.path.exists(sub_config_path):
return True
return False
async def _process_sub_damage(sub_rid: str) -> None:
"""异步处理单个子目录的数据。
Args:
sub_rid (str): 子运行ID。
"""
# prepare_dmg_data_and_cache 不是异步函数，使用 to_thread
await asyncio.to_thread(prepare_dmg_data_and_cache, sub_rid)
async def _process_sub_buff(sub_rid: str) -> None:
"""异步处理单个子目录的数据。
Args:
sub_rid (str): 子运行ID。
"""
await prepare_buff_data_and_cache(sub_rid)
async def prepare_parallel_data_and_cache(rid: int | str) -> None:
"""对并行模式的每一份报告进行数据预处理，并将结果缓存到本地（异步执行）。
Args:
rid (int | str): 运行ID。
"""
result_dir = os.path.join(results_dir, str(rid))
parallel_config_path = os.path.join(result_dir, ".parallel_config.json")
try:
with open(parallel_config_path, "r", encoding="utf-8") as f:
parallel_config: dict = json.load(f)
except (json.JSONDecodeError, IOError) as e:
st.error(f"读取或解析并行配置文件 {parallel_config_path} 失败: {e}")
return
if parallel_config.get("adjust_sc", {}).get("enabled", False):
merged_sc_file_path = os.path.join(result_dir, "merged_sc_data.json")
if os.path.exists(merged_sc_file_path):
return
tasks = []
for item in os.listdir(result_dir):
sub_dir_path = os.path.join(result_dir, item)
if os.path.isdir(sub_dir_path):
sub_config_path = os.path.join(sub_dir_path, "sub.parallel_config.json")
if os.path.exists(sub_config_path):
sub_rid: str = os.path.join(str(rid), item) # 子进程rid
# 创建异步任务
tasks.append(_process_sub_damage(sub_rid))
# 并发执行所有任务
if tasks:
await asyncio.gather(*tasks)
# 统计并行模式的个子进程伤害归并结果
async def merge_parallel_dmg_data(
rid: int | str,
) -> tuple[str, dict[str, Any]] | None:
"""对并行模式的每一份报告进行数据预处理，并将结果缓存到本地。
Args:
rid (int): 运行ID。
"""
result_dir = os.path.join(results_dir, str(rid))
parallel_config_path = os.path.join(result_dir, ".parallel_config.json")
async with aiofiles.open(parallel_config_path, "r", encoding="utf-8") as f:
parallel_config: dict = json.loads(await f.read())
if parallel_config.get("adjust_sc", {}).get("enabled", False):
# 属性收益曲线功能
func = "attr_curve"
merged_sc_file_path = os.path.join(result_dir, "merged_sc_data.json")
sc_merged_data = {}
if os.path.exists(merged_sc_file_path):
async with aiofiles.open(merged_sc_file_path, "r", encoding="utf-8") as f:
sc_merged_data = json.loads(await f.read())
else:
try:
st.info("首次处理读取属性收益曲线数据，请稍等...")
sc_merged_data = await _merge_attr_curve_data(rid)
st.success("属性收益曲线数据合并完成！")
# 将合并后的数据保存到 JSON 文件
try:
async with aiofiles.open(merged_sc_file_path, "w", encoding="utf-8") as f:
await f.write(json.dumps(sc_merged_data, indent=4, ensure_ascii=False))
st.success(f"合并的属性收益曲线数据已保存至 {merged_sc_file_path}")
except IOError as e:
st.error(f"保存合并的属性收益曲线数据失败: {e}")
except Exception as e:
st.error(f"合并属性收益曲线数据时出错: {e}")
return func, sc_merged_data
elif parallel_config.get("adjust_weapon", {}).get("enabled", False):
# 武器切换功能
func = "weapon"
merged_weapon_file_path = os.path.join(result_dir, "merged_weapon_data.json")
weapon_merged_data = {}
if os.path.exists(merged_weapon_file_path):
async with aiofiles.open(merged_weapon_file_path, "r", encoding="utf-8") as f:
weapon_merged_data = json.loads(await f.read())
else:
try:
st.info("首次处理读取武器切换数据，请稍等...")
weapon_merged_data = await _merge_weapon_data(rid)
st.success("武器切换数据合并完成！")
# 将合并后的数据保存到 JSON 文件
try:
async with aiofiles.open(merged_weapon_file_path, "w", encoding="utf-8") as f:
await f.write(json.dumps(weapon_merged_data, indent=4, ensure_ascii=False))
st.success(f"合并的武器切换数据已保存至 {merged_weapon_file_path}")
except IOError as e:
st.error(f"保存合并的武器切换数据失败: {e}")
except Exception as e:
st.error(f"合并武器切换数据时出错: {e}")
return func, weapon_merged_data
else:
return None
def __draw_attr_curve(
sc_merged_data: dict[str, dict[str, dict[int | float, dict[str, float | None]]]],
) -> None:
"""绘制属性收益曲线折线图"""
if sc_merged_data:
for char_name, char_data in sc_merged_data.items():
fig = go.Figure()
has_data = False # 标记是否有数据添加到图表中
x_values = [] # 初始化x_values
for sc_name, sc_values_results in char_data.items():
# sc_values_results 的结构现在是 {sc_value: {"result": float, "rate": float | None}}
# 数据在 merge_parallel_sc_data 中已经按 sc_value 排序
if not sc_values_results:
st.warning(f"角色 '{char_name}' 的词条 '{sc_name}' 没有数据，跳过绘制。")
continue
# 提取 x 值 (词条值) 和 y 值 (收益率)
x_values_raw = list(sc_values_results.keys())
# 提取预计算的收益率，跳过第一个点（收益率通常为None）
y_values_rate = [data.get("rate") for data in sc_values_results.values()]
# 尝试将 x 值转换为浮点数
try:
x_values = [float(x) for x in x_values_raw]
except ValueError:
st.warning(
f"角色 '{char_name}' 的词条 '{sc_name}' 包含非数值的 x 值，跳过绘制。"
)
continue
# 确保有足够的数据点来绘制收益率（至少需要两个原始点才能计算一个收益率点）
if len(x_values) < 2:
st.warning(
f"角色 '{char_name}' 的词条 '{sc_name}' 数据点不足 (<2)，无法绘制收益率曲线。"
)
continue
# 过滤掉第一个点的 x 值和 y 值（因为第一个点没有收益率）
# 同时处理 y_values_rate 中可能存在的 None 值
plot_x_values = []
plot_y_values = []
for i in range(1, len(x_values)):
if y_values_rate[i] is not None:
plot_x_values.append(x_values[i])
plot_y_values.append(y_values_rate[i])
if not plot_x_values:
st.warning(
f"角色 '{char_name}' 的词条 '{sc_name}' 没有有效的收益率数据点，跳过绘制。"
)
continue
fig.add_trace(
go.Scatter(
x=plot_x_values, # 使用过滤后的 x 值
y=plot_y_values, # 使用过滤后的 y 值 (收益率)
mode="lines+markers",
name=reversed_stats_trans_mapping.get(sc_name, sc_name),
connectgaps=False, # 不连接 None 值造成的断点
)
)
has_data = True
if has_data:
# 计算整数刻度 (基于原始的所有 x_values)
try:
# 确保只使用数值类型的 x 值
numeric_x_values = [x for x in x_values if isinstance(x, (int, float))]
if not numeric_x_values:
raise ValueError("No numeric x values found")
min_x = min(numeric_x_values)
max_x = max(numeric_x_values)
# 生成从最小整数到最大整数的所有整数刻度
integer_ticks = list(
range(
int(min_x) if min_x == int(min_x) else int(min_x) + 1,
int(max_x) + 1,
)
)
# 如果最小值本身是整数，也包含它
if isinstance(min_x, int) or (isinstance(min_x, float) and min_x.is_integer()):
if int(min_x) not in integer_ticks:
integer_ticks.insert(0, int(min_x))
integer_ticks.sort() # 确保刻度排序
except ValueError: # 如果 x_values 为空或不包含数字
integer_ticks = []
# fmt: off
fig.update_layout(
title=f"{char_name} - 属性收益曲线",
xaxis_title="词条数",
yaxis_title="收益率", # 更新 Y 轴标题
hovermode="x unified",
yaxis=dict(tickformat=".2%"), # 将 Y 轴格式化为百分比
xaxis=dict(
tickmode="array" if integer_ticks else "auto", # 如果有计算出的整数刻度则使用array模式
tickvals=integer_ticks if integer_ticks else None, # 设置刻度值为整数
tickformat="d", # 强制显示为整数
),
)
st.plotly_chart(fig, use_container_width=True)
else:
st.warning(f"角色 '{char_name}' 没有足够的数据来绘制组合图表。")
# fmt: on
else:
st.warning("没有可用于绘制属性收益曲线的数据。")
def __draw_weapon_data(
weapon_merged_data: dict[str, dict[str, dict[str, dict[str, Any]]]],
) -> None:
"""绘制武器对比柱状图"""
if weapon_merged_data:
for char_name, char_data in weapon_merged_data.items():
fig = go.Figure()
has_data = False # 标记是否有数据添加到图表中
# 收集所有武器和精炼等级的数据
weapons_data = {}
for weapon_name, weapon_levels in char_data.items():
if not weapon_levels:
st.warning(f"角色 '{char_name}' 的武器 '{weapon_name}' 没有数据，跳过绘制。")
continue
# 为每个精炼等级收集伤害数据
for level, level_data in weapon_levels.items():
damage = level_data.get("damage", 0.0)
if weapon_name not in weapons_data:
weapons_data[weapon_name] = {}
weapons_data[weapon_name][level] = damage
# 如果没有收集到数据，跳过此角色
if not weapons_data:
st.warning(f"角色 '{char_name}' 没有可用的武器数据，跳过绘制。")
continue
# 收集所有独特的精炼等级
all_levels = sorted(
list(
set(
level
for levels_data in weapons_data.values()
for level in levels_data.keys()
)
)
)
all_weapon_names = list(weapons_data.keys())
# 为每个精炼等级创建柱状图系列
for level in all_levels:
level_damages = []
for weapon_name in all_weapon_names:
# 获取该武器在该精炼等级的伤害，如果不存在则为0
damage = weapons_data.get(weapon_name, {}).get(level, 0.0)
level_damages.append(damage)
if any(d > 0 for d in level_damages): # 只添加有数据的精炼等级系列
fig.add_trace(
go.Bar(
x=all_weapon_names, # 武器名称作为 X 轴
y=level_damages,
name=f"精炼 {level}", # 精炼等级作为系列名称
text=[f"{damage:.2f}" for damage in level_damages],
textposition="auto",
)
)
has_data = True
if has_data:
# 更新图表布局
fig.update_layout(
title=f"{char_name} - 武器伤害对比",
xaxis_title="武器名称", # 更新 X 轴标题
yaxis_title="总伤害",
barmode="group", # 分组模式，按 X 轴（武器名称）分组
hovermode="x unified",
)
st.plotly_chart(fig, use_container_width=True)
else:
st.warning(f"角色 '{char_name}' 没有足够的数据来绘制武器对比图表。")
else:
st.warning("没有可用于绘制武器对比图表的数据。")
async def _read_json_file(file_path: str) -> dict[str, Any]:
"""异步读取JSON文件。
Args:
file_path (str): JSON文件路径。
Returns:
dict[str, Any]: 读取到的JSON内容，如果失败则返回空字典。
"""
try:
async with aiofiles.open(file_path, mode="r", encoding="utf-8") as f:
content = await f.read()
return json.loads(content)
except (FileNotFoundError, json.JSONDecodeError, IOError) as e:
# TODO: 使用更健壮的日志记录
print(f"Error reading JSON file {file_path}: {e}")
return {}
async def _collect_sub_parallel_data(
rid: int | str,
) -> list[dict[str, Any]]:
"""异步收集所有子进程的并行配置和伤害数据。
Args:
rid (int | str): 运行ID。
Returns:
list[dict[str, Any]]: 包含每个子进程配置和伤害数据的列表。
每个字典包含 'sub_config', 'sc_data', 'sub_dir_path'。
"""
result_dir: str = os.path.join(results_dir, str(rid))
tasks = []
sub_dir_paths_map: dict[int, str] = {} # 存储 task index 到 sub_dir_path 的映射
collected_data: list[dict[str, Any]] = []
# 收集需要读取的文件路径
task_index = 0
for item in os.listdir(result_dir):
sub_dir_path = os.path.join(result_dir, item)
if os.path.isdir(sub_dir_path):
sub_config_path = os.path.join(sub_dir_path, "sub.parallel_config.json")
dmg_attribution_path = os.path.join(sub_dir_path, "damage_attribution.json")
if os.path.exists(sub_config_path) and os.path.exists(dmg_attribution_path):
# 添加读取配置文件的任务
tasks.append(_read_json_file(sub_config_path))
sub_dir_paths_map[task_index] = sub_dir_path # 记录config对应的目录
task_index += 1
# 添加读取伤害数据的任务
tasks.append(_read_json_file(dmg_attribution_path))
sub_dir_paths_map[task_index] = sub_dir_path # 记录dmg对应的目录
task_index += 1
# 并发执行所有文件读取任务
if not tasks:
print(f"在 {result_dir} 中未找到有效的子进程结果目录。")
return []
results = await asyncio.gather(*tasks)
# 处理读取结果
i = 0
while i < len(results):
sub_config: dict[str, Any] = results[i]
sc_data: dict[str, Any] = results[i + 1]
current_sub_dir = sub_dir_paths_map.get(i, "未知子目录") # 获取对应的子目录路径
i += 2
if not sub_config:
print(
f"警告：跳过子目录 {current_sub_dir}，因为 sub.parallel_config.json 读取失败或为空。"
)
continue
if not sc_data:
print(
f"警告：跳过子目录 {current_sub_dir}，因为 damage_attribution.json 读取失败或为空。"
)
continue
collected_data.append(
{
"sub_config": sub_config,
"sc_data": sc_data,
"sub_dir_path": current_sub_dir,
}
)
return collected_data
async def _merge_attr_curve_data(
rid: int | str,
) -> dict[str, dict[str, dict[int | float, dict[str, float | None]]]]:
"""读取所有子进程的属性收益曲线数据，合并并计算收益率。
Args:
rid (int | str): 运行ID。
Returns:
dict[str, dict[str, dict[int | float, dict[str, float | None]]]]: {
角色名(adjust_char): {
词条名(sc_name): {
词条值(sc_value): {
"result": 原始结果(sc_result: float),
"rate": 收益率(rate_of_return: float | None)
}
}
}
}
"""
all_sc_data: dict[str, dict[str, dict[int | float | None, float | None]]] = {}
collected_data = await _collect_sub_parallel_data(rid)
for item in collected_data:
sub_config = item["sub_config"]
sc_data = item["sc_data"]
current_sub_dir = item["sub_dir_path"]
adjust_char: str | None = sub_config.get("adjust_char")
sc_name: str | None = sub_config.get("sc_name")
# sc_value 可能是 int 或 float
sc_value_raw: Any = sub_config.get("sc_value")
sc_value: int | float | None = None
if isinstance(sc_value_raw, (int, float)):
sc_value = sc_value_raw
if adjust_char is None or sc_name is None or sc_value is None:
print(
f"警告：跳过子目录 {current_sub_dir}，缺少必要的配置信息 (adjust_char, sc_name, sc_value)。"
)
continue
# damage_attribution.json 处理
char_dmg_data: dict[str, Any] | None = sc_data.get(adjust_char)
if char_dmg_data is None:
print(
f"警告：跳过子目录 {current_sub_dir}，在 damage_attribution.json 中未找到角色 '{adjust_char}' 的数据。"
)
continue
# 伤害数据包含 direct_damage 和 anomaly_damage
direct_damage: float = char_dmg_data.get("direct_damage", 0.0)
anomaly_damage: float = char_dmg_data.get("anomaly_damage", 0.0)
sc_result: float = direct_damage + anomaly_damage
# 填充结果字典
if adjust_char not in all_sc_data:
all_sc_data[adjust_char] = {}
if sc_name not in all_sc_data[adjust_char]:
all_sc_data[adjust_char][sc_name] = {}
# 检查 sc_value 是否已存在，如果存在则打印警告（理论上并行配置不应重复）
if sc_value in all_sc_data[adjust_char][sc_name]:
print(
f"警告：在角色 '{adjust_char}' 的词条 '{sc_name}' 中，词条值 '{sc_value}' 重复出现。来自子目录: {current_sub_dir}"
)
# 存储原始结果
all_sc_data[adjust_char][sc_name][sc_value] = { # type: ignore
"result": sc_result,
"rate": None,
}
# 对每个词条的值按 sc_value 排序并计算收益率
for char_name, char_data in all_sc_data.items():
for sc_name_key, sc_values_data in char_data.items():
# 按 sc_value 排序
try:
# 尝试将键转换为浮点数进行排序
# 过滤掉 sc_value 为 None 的项再排序
filtered_items = [(k, v) for k, v in sc_values_data.items() if k is not None]
sorted_items = sorted(filtered_items, key=lambda item: float(item[0]))
except ValueError:
# 如果转换失败，按原始键（字符串）排序
sorted_items = [(k, v) for k, v in sc_values_data.items() if k is not None]
sorted_items = sorted(sorted_items, key=lambda item: str(item[0]))
# 更新排序后的字典，并计算收益率
sorted_sc_data: dict[int | float, dict[str, float | None]] = {}
previous_result: float | None = None
for i, (sc_val, data) in enumerate(sorted_items):
current_result = data["result"] # type: ignore
rate = None
if i > 0 and previous_result is not None and previous_result != 0:
rate = (current_result / previous_result) - 1
sorted_sc_data[sc_val] = {"result": current_result, "rate": rate}
previous_result = current_result
# 用包含收益率的排序后字典替换原来的字典
all_sc_data[char_name][sc_name_key] = sorted_sc_data # type: ignore
return all_sc_data # type: ignore
async def _merge_weapon_data(
rid: int | str,
) -> dict[str, dict[str, dict[str, dict[str, Any]]]]:
"""读取所有子进程的武器切换数据，合并并计算平均伤害。
Args:
rid (int | str): 运行ID。
Returns:
dict[str, dict[str, dict[str, dict[str, Any]]]]: {
角色名(adjust_char): {
武器名(weapon_name): {
精炼等级{weapon_level}: {
"damage": 总伤害加权,
}
}
}
}
"""
all_weapon_data: dict[str, dict[str, dict[str, dict[str, Any]]]] = {}
collected_data = await _collect_sub_parallel_data(rid)
for item in collected_data:
sub_config = item["sub_config"]
sc_data = item["sc_data"]
current_sub_dir = item["sub_dir_path"]
adjust_char: str | None = sub_config.get("adjust_char")
weapon_name: str | None = sub_config.get("weapon_name")
weapon_level: str | None = sub_config.get("weapon_level")
if adjust_char is None or weapon_name is None or weapon_level is None:
print(
f"警告：跳过子目录 {current_sub_dir}，缺少必要的配置信息 (adjust_char, weapon_name, weapon_level)。"
)
continue
char_dmg_data: dict[str, Any] | None = sc_data.get(adjust_char)
if char_dmg_data is None:
print(
f"警告：跳过子目录 {current_sub_dir}，在 damage_attribution.json 中未找到角色 '{adjust_char}' 的数据。"
)
continue
# 伤害数据包含 direct_damage 和 anomaly_damage
direct_damage: float = char_dmg_data.get("direct_damage", 0.0)
anomaly_damage: float = char_dmg_data.get("anomaly_damage", 0.0)
total_damage: float = direct_damage + anomaly_damage
# 填充结果字典
if adjust_char not in all_weapon_data:
all_weapon_data[adjust_char] = {}
if weapon_name not in all_weapon_data[adjust_char]:
all_weapon_data[adjust_char][weapon_name] = {}
# 检查 weapon_level 是否已存在，如果存在则打印警告（理论上并行配置不应重复）
if weapon_level in all_weapon_data[adjust_char][weapon_name]:
print(
f"警告：在角色 '{adjust_char}' 的武器 '{weapon_name}' 中，精炼等级 '{weapon_level}' 重复出现。来自子目录: {current_sub_dir}"
)
# 存储总伤害
all_weapon_data[adjust_char][weapon_name][weapon_level] = {
"damage": total_damage,
}
return all_weapon_data
def process_parallel_result(rid: int | str) -> None:
"""处理并行模式的结果。
Args:
rid (int): 运行ID。
"""
result_dir = os.path.join(results_dir, str(rid))
# 1. 预处理每个子目录的数据（伤害、Buff等）
with st.spinner("开始预处理并行子目录数据，初次处理会持续一段时间...", show_time=True):
asyncio.run(prepare_parallel_data_and_cache(rid))
# 2. 合并需要聚合的数据（例如属性收益曲线或武器对比）
result = asyncio.run(merge_parallel_dmg_data(rid))
# 3. 绘制图表
if result:
func, merged_data = result
if func == "attr_curve":
__draw_attr_curve(merged_data)
elif func == "weapon":
__draw_weapon_data(merged_data)
# 4. 获取有效的子目录列表
sub_dirs = []
if os.path.isdir(result_dir):
for item in os.listdir(result_dir):
sub_dir_path = os.path.join(result_dir, item)
if os.path.isdir(sub_dir_path):
sub_config_path = os.path.join(sub_dir_path, "sub.parallel_config.json")
if os.path.exists(sub_config_path):
sub_dirs.append(item) # 添加子目录名称
st.markdown("--- ")
st.write("选择要查看的子进程报告")
col1, col2 = st.columns(2)
selected_key = sub_dirs[0]
with col1:
# 5. 添加下拉选择框以选择子进程报告
if sub_dirs:
selected_sub_dir = st.selectbox(
"选择要查看的子进程报告",
options=sub_dirs,
index=0,
key=f"selectbox_sub_dir_{rid}",
label_visibility="collapsed",
)
selected_key = f"{rid}/{selected_sub_dir}"
with col2:
# 6. 提供按钮处理全部buff结果以节约储存
if st.button(
"处理全部BUFF结果",
key="toggle_buff_all",
help="处理所有buff结果可以节约大量储存空间，但耗时较长",
):
with st.spinner("开始处理所有子进程BUFF结果...", show_time=True):
async def process_all_sub_buff():
"""处理所有子进程的BUFF结果。"""
tasks = []
for sub_dir in sub_dirs:
sub_rid = f"{rid}/{sub_dir}"
tasks.append(_process_sub_buff(sub_rid))
await asyncio.gather(*tasks)
asyncio.run(process_all_sub_buff())
if st.button("显示子进程伤害结果", key="toggle_dmg_all"):
show_dmg_result(selected_key)
show_buff_result(selected_key)
else:
st.info("未找到有效的子进程结果目录。")
# TODO: 添加其他并行结果的处理逻辑，例如生成聚合报告、绘制对比图表等。
st.warning("并行模式的结果合并与展示功能仍在开发中。", icon="⚠️")
================================================
FILE: zsim/lib_webui/process_simulator.py
================================================
import json
import os
import shutil
from typing import Any, Iterator
import polars as pl
import streamlit as st
from zsim.define import config_path
from zsim.lib_webui.process_apl_editor import APLArchive, APLJudgeTool
from zsim.simulator.config_classes import (
ExecAttrCurveCfg,
ExecWeaponCfg,
)
from zsim.simulator.config_classes import SimulationConfig as SimCfg
from .constants import stats_trans_mapping
def generate_parallel_args(
stop_tick: int,
parallel_cfg: dict,
run_turn_uuid: str,
) -> Iterator[SimCfg]:
"""生成用于并行模拟的参数。
Args:
stop_tick: 模拟停止的 tick 数。
parallel_cfg: 并行模式的配置字典。
run_turn_uuid: 当前运行轮次的 UUID。
Yields:
MainArgs: 为每个模拟任务生成的参数对象。
"""
# Determine the function based on enabled flags
func = None
if parallel_cfg.get("adjust_sc", {}).get("enabled", False):
func = "attr_curve"
elif parallel_cfg.get("adjust_weapon", {}).get("enabled", False):
func = "weapon"
if func == "attr_curve":
adjust_sc_cfg = parallel_cfg["adjust_sc"]
sc_list = adjust_sc_cfg["sc_list"]
sc_range_start, sc_range_end = adjust_sc_cfg["sc_range"]
remove_equip_list = adjust_sc_cfg.get(
"remove_equip_list", []
) # 获取需要移除装备的词条列表，如果不存在则为空列表
for sc_name in sc_list:
for sc_value in range(sc_range_start, sc_range_end + 1):
args = ExecAttrCurveCfg(
stop_tick=stop_tick,
mode="parallel",
func=func,
adjust_char=parallel_cfg["adjust_char"],
sc_name=stats_trans_mapping[sc_name],
sc_value=sc_value,
run_turn_uuid=run_turn_uuid,
remove_equip=sc_name in remove_equip_list,
)
yield args
elif func == "weapon":
adjust_weapon_cfg = parallel_cfg["adjust_weapon"]
weapon_list = adjust_weapon_cfg["weapon_list"]
for weapon in weapon_list:
args = ExecWeaponCfg(
stop_tick=stop_tick,
mode="parallel",
func=func,
adjust_char=parallel_cfg["adjust_char"],
weapon_name=weapon["name"],
weapon_level=weapon["level"],
run_turn_uuid=run_turn_uuid,
)
yield args
else:
raise ValueError(f"Unknown func: {func}, full cfg: {parallel_cfg}")
def apl_selecter():
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
default_apl_path = config["database"]["APL_FILE_PATH"]
apl_archive = APLArchive()
default_apl_titile = apl_archive.get_title_from_path(default_apl_path)
options_list = list(apl_archive.options or [])
# 检查 default_apl_titile 是否在选项列表中
if default_apl_titile in options_list:
default_index = options_list.index(default_apl_titile)
else:
default_index = 0 # 如果不在，则默认选择第一个选项
selected_title = st.selectbox(
"APL选项",
options_list,
label_visibility="collapsed",
index=default_index,
)
return selected_title
def save_apl_selection(selected_title: str):
"""保存APL选择。
Args:
selected_title: 选中的APL标题。
"""
apl_archive = APLArchive()
original_path = apl_archive.get_origin_relative_path(selected_title)
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
config["database"]["APL_FILE_PATH"] = original_path
with open(config_path, "w", encoding="utf-8") as f:
json.dump(config, f, indent=4)
def get_default_apl_tile() -> str | None:
"""获取默认APL的标题。
Returns:
str: 默认APL的标题。
"""
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
default_apl_path = config["database"]["APL_FILE_PATH"]
apl_archive = APLArchive()
return apl_archive.get_title_from_path(default_apl_path)
def show_apl_judge_result(selected_title: str | None = None) -> bool:
"""显示并返回判断结果APL的判断结果。
Args:
selected_title (str): 选中的APL标题。
Returns:
bool: 判断结果APL的判断结果。
"""
if selected_title is None:
selected_title = get_default_apl_tile()
if selected_title is None:
st.error("未找到默认APL，请先选择一个APL。")
return False
apl_archive = APLArchive()
apl_data: dict[str, Any] | None = apl_archive.get_apl_data(selected_title)
if apl_data is None:
st.error("未找到APL数据，请检查APL文件是否正确。")
return False
apl_judge_tool = APLJudgeTool(apl_data)
required_chars_result: tuple[bool, list[str]] = apl_judge_tool.judge_requried_chars()
option_result_result: tuple[bool, list[str]] = apl_judge_tool.judge_optional_chars()
char_config_result: tuple[bool, dict[str, str | int]] = apl_judge_tool.judge_char_config()
if required_chars_result[0]:
st.success("必选角色满足要求")
else:
st.error(f"必选角色缺少：{required_chars_result[1]}")
if option_result_result[0]:
st.success("可选角色满足要求")
else:
st.error(f"可选角色缺少：{option_result_result[1]}")
if char_config_result[0]:
st.success("角色配置满足要求")
else:
st.error(f"角色配置缺少：{char_config_result[1]}")
return required_chars_result[0] and char_config_result[0]
def enemy_selector() -> None:
"""敌人配置选择器界面。"""
# 从enemy.csv获取所有唯一的IndexID和CN_enemy_ID，并按IndexID排序
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
saved_index = config["enemy"]["index_ID"]
saved_adjust = config["enemy"]["adjust_ID"]
# 只在首次加载时初始化session_state
if "enemy_index" not in st.session_state:
st.session_state["enemy_index"] = saved_index
if "enemy_adjust" not in st.session_state:
st.session_state["enemy_adjust"] = saved_adjust
# 获取所有可选项
enemy_lf = pl.scan_csv("zsim/data/enemy.csv")
enemy_data: pl.DataFrame = (
enemy_lf.select(["IndexID", "CN_enemy_ID"])
.unique(subset=["IndexID"])
.sort(by="IndexID", descending=True)
.collect()
)
enemy_options = []
enemy_values = []
for index_id, cn_enemy_id in enemy_data.iter_rows():
display_text = f"{index_id} - {cn_enemy_id}"
enemy_options.append(display_text)
enemy_values.append(index_id)
adjust_df = pl.scan_csv("zsim/data/enemy_adjustment.csv")
adjust_options: list[int] = sorted(
adjust_df.select("ID").unique().collect().to_series().to_list()
)
col_enemy1, col_enemy2 = st.columns(2)
with col_enemy1:
# 找到当前IndexID对应的显示选项索引
try:
current_index_pos = enemy_values.index(st.session_state["enemy_index"])
except ValueError:
current_index_pos = 0
selected_display = st.selectbox(
"选择敌人",
enemy_options,
index=current_index_pos,
help="数值为IndexID，同一个名字的怪物可能有不同的IndexID，他们的各项属性不同，选择时请注意",
key="enemy_index_selectbox",
)
selected_index = enemy_values[enemy_options.index(selected_display)]
with col_enemy2:
try:
current_adjust_pos = adjust_options.index(st.session_state["enemy_adjust"])
except ValueError:
current_adjust_pos = 0
selected_adjust = st.selectbox(
"敌人属性调整ID",
adjust_options,
index=current_adjust_pos,
help="一般每个关卡对应一个调整ID，不知道是什么的话就不改",
key="enemy_adjust_selectbox",
)
# 更新session_state为当前选择
st.session_state["enemy_index"] = selected_index
st.session_state["enemy_adjust"] = selected_adjust
# 检查是否有未保存的更改
if (
st.session_state["enemy_index"] != saved_index
or st.session_state["enemy_adjust"] != saved_adjust
):
st.session_state["enemy_config_unsaved"] = True
else:
st.session_state["enemy_config_unsaved"] = False
def save_enemy_selection(index_id: int, adjust_id: int):
"""保存敌人配置选择。
Args:
index_id: 选中的敌人基础ID
adjust_id: 选中的敌人调整ID
"""
# 创建配置文件临时备份
backup_path = config_path.parent / "config.json.bak"
shutil.copy(config_path, backup_path)
try:
# 部分更新配置文件
with open(config_path, "r+", encoding="utf-8") as f:
config = json.load(f)
# 只更新需要的部分
config["enemy"]["index_ID"] = index_id
config["enemy"]["adjust_ID"] = adjust_id
# 写回文件
f.seek(0)
json.dump(config, f, indent=4)
f.truncate()
except Exception as e:
# 出错时恢复备份
print(f"保存配置出错: {e}")
shutil.move(backup_path, config_path)
raise
finally:
# 清理备份
if os.path.exists(backup_path):
os.remove(backup_path)
#
# with open(CONFIG_PATH, "r", encoding="utf-8") as f:
# config = json.load(f)
#
# config["enemy"]["index_ID"] = index_id
# config["enemy"]["adjust_ID"] = adjust_id
#
# with open(CONFIG_PATH, "w", encoding="utf-8") as f:
# json.dump(config, f, indent=4)
================================================
FILE: zsim/lib_webui/version_checker.py
================================================
import json
import re
import webbrowser
from typing import Any
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen
import streamlit as st
from zsim.define import GITHUB_REPO_NAME, GITHUB_REPO_OWNER, __version__
class GitHubVersionChecker:
"""GitHub版本检查器"""
def __init__(self, repo_owner: str, repo_name: str, current_version: str):
"""
初始化版本检查器
Args:
repo_owner: GitHub仓库所有者
repo_name: GitHub仓库名称
current_version: 当前版本号
"""
self.repo_owner = repo_owner
self.repo_name = repo_name
self.current_version = current_version
self.api_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/latest"
self.repo_url = f"https://github.com/{repo_owner}/{repo_name}"
def _parse_version(self, version: str) -> tuple[list, str, int]:
"""
解析版本号，支持预发布版本
Args:
version: 版本号字符串，如 "1.2.3a1" 或 "1.2.3"
Returns:
tuple: (主版本号列表, 预发布类型, 预发布版本号)
例如: ([1, 2, 3], "a", 1) 或 ([1, 2, 3], "", 0)
"""
# 移除版本号前的 'v' 前缀
clean_version = version.lstrip("v")
# 使用正则表达式匹配版本号格式
# 匹配格式: 数字.数字.数字[预发布标识符数字]
pattern = r"^(\d+(?:\.\d+)*?)([a-zA-Z]+)?(\d+)?$"
match = re.match(pattern, clean_version)
if not match:
# 如果不匹配，尝试简单的数字版本
try:
main_parts = [int(x) for x in clean_version.split(".")]
return main_parts, "", 0
except ValueError:
# 如果解析失败，返回默认值
return [0], "", 0
main_version = match.group(1)
prerelease_type = match.group(2) or ""
prerelease_num = int(match.group(3)) if match.group(3) else 0
# 解析主版本号
try:
main_parts = [int(x) for x in main_version.split(".")]
except ValueError:
main_parts = [0]
return main_parts, prerelease_type, prerelease_num
def _compare_versions(self, version1: str, version2: str) -> int:
"""
比较两个版本号，支持预发布版本
Args:
version1: 版本号1
version2: 版本号2
Returns:
-1: version1 < version2
0: version1 == version2
1: version1 > version2
"""
# 解析版本号
v1_main, v1_pre_type, v1_pre_num = self._parse_version(version1)
v2_main, v2_pre_type, v2_pre_num = self._parse_version(version2)
# 补齐主版本号长度
max_len = max(len(v1_main), len(v2_main))
v1_main.extend([0] * (max_len - len(v1_main)))
v2_main.extend([0] * (max_len - len(v2_main)))
# 首先比较主版本号
for i in range(max_len):
if v1_main[i] < v2_main[i]:
return -1
elif v1_main[i] > v2_main[i]:
return 1
# 主版本号相同，比较预发布版本
# 预发布版本的优先级：无预发布 > rc > b > a
prerelease_priority = {"": 4, "rc": 3, "b": 2, "a": 1}
v1_priority = prerelease_priority.get(v1_pre_type.lower(), 0)
v2_priority = prerelease_priority.get(v2_pre_type.lower(), 0)
if v1_priority != v2_priority:
return -1 if v1_priority < v2_priority else 1
# 预发布类型相同，比较预发布版本号
if v1_pre_type and v2_pre_type: # 都是预发布版本
if v1_pre_num < v2_pre_num:
return -1
elif v1_pre_num > v2_pre_num:
return 1
return 0
def check_for_updates(self, timeout: int = 10) -> dict[str, Any] | None:
"""
检查是否有新版本
Args:
timeout: 请求超时时间（秒）
Returns:
如果有新版本，返回包含版本信息的字典；否则返回None
"""
try:
# 创建请求
request = Request(
self.api_url,
headers={
"User-Agent": "ZZZ-Simulator-Version-Checker",
"Accept": "application/vnd.github.v3+json",
},
)
# 发送请求
with urlopen(request, timeout=timeout) as response:
if response.status == 200:
data = json.loads(response.read().decode("utf-8"))
latest_version = data.get("tag_name", "")
if not latest_version:
return None
# 比较版本
if self._compare_versions(self.current_version, latest_version) < 0:
return {
"latest_version": latest_version,
"current_version": self.current_version,
"release_url": data.get("html_url", self.repo_url),
"release_name": data.get("name", latest_version),
"release_body": data.get("body", ""),
"published_at": data.get("published_at", ""),
"download_url": data.get("zipball_url", ""),
}
return None
else:
print(f"GitHub API请求失败，状态码: {response.status}")
return None
except (URLError, HTTPError, json.JSONDecodeError, ValueError) as e:
print(f"检查更新时发生错误: {e}")
return None
@st.dialog("发现新版本")
def show_update_dialog(self, update_info: dict[str, Any]) -> None:
"""
显示更新对话框
Args:
update_info: 更新信息字典
"""
# 使用容器来确保对话框显示在顶部
with st.container():
st.success(f"🎉 发现新版本: {update_info['latest_version']}")
with st.expander("📋 查看更新详情", expanded=False):
col_info1, col_info2 = st.columns(2)
with col_info1:
st.markdown(f"**当前版本:** `v{update_info['current_version']}`")
if update_info.get("published_at"):
st.markdown(f"**发布时间:** {update_info['published_at'][:10]}")
with col_info2:
st.markdown(f"**最新版本:** `{update_info['latest_version']}`")
if update_info.get("release_name"):
st.markdown(f"**发布标题:** {update_info['release_name']}")
if update_info.get("release_body"):
st.markdown("**更新说明:**")
# 限制更新说明的长度，避免界面过长
release_body = update_info["release_body"]
if len(release_body) > 500:
release_body = release_body[:500] + "..."
st.markdown(release_body)
# 按钮布局
col1, col2 = st.columns(2)
with col1:
if st.button(
"🔗 前往发布页",
type="primary",
use_container_width=True,
key="download_btn",
):
webbrowser.open(update_info["release_url"])
st.success("已在浏览器中打开下载页面")
st.session_state.update_dismissed = True
with col2:
if st.button("❌ 暂不更新", use_container_width=True, key="dismiss_btn"):
st.session_state.update_dismissed = True
st.rerun()
def check_github_updates() -> None:
"""
检查GitHub更新的主函数
从pyproject.toml读取当前版本，检查GitHub仓库是否有新版本
"""
# 避免重复检查
if st.session_state.get("update_checked", False) or st.session_state.get(
"update_dismissed", False
):
return
try:
current_version = __version__
# 创建版本检查器
checker = GitHubVersionChecker(
repo_owner=GITHUB_REPO_OWNER,
repo_name=GITHUB_REPO_NAME,
current_version=current_version,
)
# 检查更新
update_info = checker.check_for_updates()
if update_info:
checker.show_update_dialog(update_info)
# 标记已检查
st.session_state.update_checked = True
except Exception as e:
print(f"检查更新时发生错误: {e}")
st.session_state.update_checked = True
================================================
FILE: zsim/main.py
================================================
import argparse
import timeit
from zsim.simulator.config_classes import (
ExecAttrCurveCfg,
ExecWeaponCfg,
)
from zsim.simulator.simulator_class import Simulator
if __name__ == "__main__":
# 创建命令行参数解析器
parser = argparse.ArgumentParser(description="ZZZ模拟器")
parser.add_argument("--stop-tick", type=int, default=None, help="指定模拟的tick数量 int")
parser.add_argument(
"--mode",
type=str,
default="normal",
choices=["normal", "parallel"],
help="运行模式",
)
parser.add_argument(
"--func",
type=str,
default=None,
choices=["attr_curve", "weapon"],
help="功能选择",
)
parser.add_argument(
"--adjust-char",
type=int,
default=None,
choices=[1, 2, 3],
help="调整的角色相对位置",
)
parser.add_argument("--sc-name", type=str, default=None, help="要调整的副词条名称 str")
parser.add_argument("--sc-value", type=int, default=None, help="要调整的副词条数量 int")
parser.add_argument("--run-turn-uuid", type=str, default=None, help="运行的uuid str")
parser.add_argument(
"--remove-equip",
action="store_true",
default=False,
help="移除装备 (存在此标志时移除)",
)
parser.add_argument(
"--weapon-name",
type=str,
default=None,
help="要调整的武器名称 str",
)
parser.add_argument(
"--weapon-level",
type=int,
default=None,
help="要调整的武器精炼等级 int",
)
# 解析命令行参数
args = parser.parse_args()
print(args)
if args.mode == "normal":
print("常规模式")
# 常规模式，作为单进程运行，读取全部的配置
simulator_instance = Simulator()
if args.stop_tick is not None:
print(
f"\n主循环耗时: {timeit.timeit(lambda: simulator_instance.main_loop(args.stop_tick), globals=globals(), number=1):.2f} s"
)
else:
print(
f"\n主循环耗时: {timeit.timeit(simulator_instance.main_loop, globals=globals(), number=1):.2f} s"
)
print("\n正在等待IO结束···")
elif args.mode == "parallel":
print("并行模式")
print(args)
simulator_instance = Simulator()
# 并行模式，作为子进程运行，角色的指定副词条将被设为传入值，并根据是否移除其他主副词条进行模拟
if func := args.func == "attr_curve":
sim_cfg: ExecAttrCurveCfg = ExecAttrCurveCfg(
stop_tick=args.stop_tick,
mode=args.mode,
adjust_char=args.adjust_char,
sc_name=args.sc_name,
sc_value=args.sc_value,
run_turn_uuid=args.run_turn_uuid,
remove_equip=args.remove_equip,
)
elif func := args.func == "weapon":
sim_cfg: ExecWeaponCfg = ExecWeaponCfg(
stop_tick=args.stop_tick,
mode=args.mode,
adjust_char=args.adjust_char,
weapon_name=args.weapon_name,
weapon_level=args.weapon_level,
run_turn_uuid=args.run_turn_uuid,
)
else:
raise ValueError("func参数错误")
if args.stop_tick is not None:
print(
f"\n主循环耗时: {timeit.timeit(lambda: simulator_instance.main_loop(args.stop_tick, sim_cfg=sim_cfg), globals=globals(), number=1):.2f} s"
)
else:
print(
f"\n主循环耗时: {timeit.timeit(lambda: simulator_instance.main_loop(sim_cfg=sim_cfg), globals=globals(), number=1):.2f} s"
)
================================================
FILE: zsim/models/character/__init__.py
================================================
================================================
FILE: zsim/models/character/character_config.py
================================================
from datetime import datetime
from typing import Optional
from pydantic import BaseModel, Field
class CharacterConfig(BaseModel):
"""角色配置数据模型"""
config_id: str = Field(description="角色配置ID，格式为 {name}_{config_name}")
name: str = Field(description="角色名称")
config_name: str = Field(description="配置名称")
weapon: str
weapon_level: int
cinema: int
crit_balancing: bool
crit_rate_limit: float
scATK_percent: int
scATK: int
scHP_percent: int
scHP: int
scDEF_percent: int
scDEF: int
scAnomalyProficiency: int
scPEN: int
scCRIT: int
scCRIT_DMG: int
drive4: str
drive5: str
drive6: str
equip_style: str
equip_set4: Optional[str] = None
equip_set2_a: Optional[str] = None
equip_set2_b: Optional[str] = None
equip_set2_c: Optional[str] = None
create_time: datetime = Field(default_factory=datetime.now, description="配置创建时间")
update_time: datetime = Field(default_factory=datetime.now, description="配置更新时间")
================================================
FILE: zsim/models/enemy/__init__.py
================================================
================================================
FILE: zsim/models/enemy/enemy_config.py
================================================
from datetime import datetime
from typing import Any, Dict
from pydantic import BaseModel, Field
class EnemyConfig(BaseModel):
"""敌人配置数据模型"""
config_id: str = Field(description="敌人配置ID")
enemy_index: int
enemy_adjust: Dict[str, Any]
create_time: datetime = Field(default_factory=datetime.now, description="配置创建时间")
update_time: datetime = Field(default_factory=datetime.now, description="配置更新时间")
================================================
FILE: zsim/models/event_enums.py
================================================
# 此文件记录了所有的和事件广播以及后置初始化有关的枚举类
from enum import Enum
class SpecialStateUpdateSignal(Enum):
"""特殊状态管理器的更新信号类"""
"""在Preload之后，广播点位位于Preload末尾，ConfirmEngine中与外部数据交互时。"""
BEFORE_PRELOAD = "BeforePreload"
"""在角色接收技能的点位广播"""
CHARACTER = "Character"
"""广播点位位于Enemy接受到攻击时候"""
RECEIVE_HIT = "ReceiveHit"
SSUS = SpecialStateUpdateSignal
class PostInitObjectType(Enum):
"""记录了所有需要后置初始化的数据的大类型，以及它们在各自的管理器中传入工厂函数所对应的参数"""
SweetScare = ("SweetScare", [SSUS.RECEIVE_HIT, SSUS.BEFORE_PRELOAD, SSUS.CHARACTER])
class ListenerBroadcastSignal(Enum):
"""监听器广播函数所涉及到的更新信号"""
SWITCHING_IN = "switching_in_event" # 角色切入前场
ENTER_BATTLE = "enter_battle_event" # 角色进入战斗
ANOMALY = "anomaly_event" # 属性异常事件
STUN = "stun_event" # 失衡事件
PARRY = "parry_event" # 招架事件
BLOCK = "block_event" # 格挡事件（其他具备格挡功能的技能响应进攻事件）
DISORDER_SPAWN = "disorder_event_spawn" # 紊乱事件产生
DISORDER_SETTLED = "disorder_event_settled" # 紊乱事件结算
ASSAULT_STATE_ON = (
"assistant_state_on" # 畏缩状态上升沿或者刷新——等价于“队伍中任意角色对敌人施加物理异常状态”
)
ASSAULT_SPAWN = "assault_spawn" # 强击触发
POLARIZED_ASSAULT_SPAWN = "polarized_assault" # 极性强击触发
================================================
FILE: zsim/models/session/__init__.py
================================================
================================================
FILE: zsim/models/session/session_create.py
================================================
from datetime import datetime
from typing import Literal
from uuid import uuid4
from pydantic import BaseModel, Field
from .session_result import NormalModeResult, ParallelModeResult
from .session_run import SessionRun
def generate_session_id() -> str:
"""Generate a unique session ID: YYYYMMDD + first 8 chars of uuid4."""
date_str = datetime.now().strftime("%Y%m%d")
uuid_part = str(uuid4())[:8]
return f"{date_str}-{uuid_part}"
class Session(BaseModel):
"""Session configuration model."""
session_id: str = Field(
default_factory=generate_session_id, description="随机生成的会话ID，为本日日期+8位UUID前缀"
)
session_name: str = Field(default="", description="会话名称")
create_time: datetime = Field(
default_factory=datetime.now, description="会话创建时间，默认当前时间"
)
session_run: SessionRun | None = None
session_result: list[NormalModeResult | ParallelModeResult] | None = None
status: Literal["pending", "running", "completed", "stopped", "failed"] = Field(
default="pending", description="会话状态"
)
if __name__ == "__main__":
print(Session())
================================================
FILE: zsim/models/session/session_result.py
================================================
from typing import Any, Literal, Self, Union
from pydantic import BaseModel, Field, RootModel
# --- Payloads for different result types ---
# --- Normal Mode ---
class DmgResult(RootModel[dict[str, Any] | None]):
"""
Represents the damage calculation results.
The root is a dictionary containing various dataframes (as list of dicts)
for detailed damage analysis. The structure is preserved from the webui
processing functions for compatibility.
"""
pass
class BuffTimelineBarValue(BaseModel):
task: str = Field(description="Buff name", alias="Task")
start: int = Field(description="Start tick of the buff", alias="Start")
finish: int = Field(description="End tick of the buff", alias="Finish")
value: float = Field(description="Buff value/stack", alias="Value")
class BuffResult(RootModel[dict[str, list[BuffTimelineBarValue]] | None]):
"""
Represents the buff timeline results.
The root is a dictionary where keys are source identifiers (e.g., file keys)
and values are lists of buff timeline points.
"""
pass
class NormalResultPayload(BaseModel):
dmg_result: DmgResult | None
buff_result: BuffResult | None
# --- Parallel Mode ---
class AttrCurvePoint(BaseModel):
result: float = Field(description="Total damage for this data point")
rate: float | None = Field(description="Rate of return compared to the previous point")
class AttrCurvePayload(RootModel[dict[str, dict[str, dict[str, AttrCurvePoint]]]]):
"""
Represents the attribute curve results.
Structure: {char_name: {sc_name: {sc_value: point_data}}}
"""
pass
class WeaponResultPoint(BaseModel):
damage: float = Field(description="Total damage for this weapon configuration")
class WeaponPayload(RootModel[dict[str, dict[str, dict[str, WeaponResultPoint]]]]):
"""
Represents the weapon comparison results.
Structure: {char_name: {weapon_name: {weapon_level: point_data}}}
"""
pass
class ParallelAttrCurveResultPayload(BaseModel):
func: Literal["attr_curve"]
result: AttrCurvePayload
class ParallelWeaponResultPayload(BaseModel):
func: Literal["weapon"]
result: WeaponPayload
class ParallelResultPayload(
RootModel[Union[ParallelAttrCurveResultPayload, ParallelWeaponResultPayload]]
):
root: Union[ParallelAttrCurveResultPayload, ParallelWeaponResultPayload] = Field(
..., discriminator="func"
)
# --- Discriminated Union Models ---
class NormalModeResult(BaseModel):
mode: Literal["normal"]
result: NormalResultPayload
class ParallelModeResult(BaseModel):
mode: Literal["parallel"]
func: Literal["attr_curve", "weapon"]
result: ParallelResultPayload
# --- Top-level SessionResult Factory Class ---
class SessionResult:
"""
This class acts as a factory for creating specific result models
(NormalModeResult or ParallelModeResult) based on the 'mode' field.
It allows instantiation like `SessionResult(mode='normal', result=...)`,
and the returned object will be a validated instance of the correct model.
This is not a Pydantic model itself, but a dispatcher.
"""
def __new__(cls, **kwargs: Any) -> Self | NormalModeResult | ParallelModeResult:
# This is not a standard Pydantic model, but a factory that returns one.
# It's designed to match the instantiation pattern in the controller.
if cls is not SessionResult:
# This allows subclasses to be instantiated normally if needed.
return super().__new__(cls)
mode = kwargs.get("mode")
if mode == "normal":
return NormalModeResult(**kwargs)
elif mode == "parallel":
return ParallelModeResult(**kwargs)
else:
raise ValueError(f"Invalid 'mode' for SessionResult: {mode}")
================================================
FILE: zsim/models/session/session_run.py
================================================
"""
单个会话的启动配置参数
初始化json样例:
session_config = SessionRun(
**{
"stop_tick": 3600,
"mode": "parallel",
"common_config": {
"session_id": "123",
"char_config": [
{"name": "角色名", "CID": 1},
{"name": "角色名", "CID": 2},
{"name": "角色名", "CID": 3},
],
"enemy_config": {
"index_id": 11451,
"adjustment_id": 22041,
"difficulty": 8.74,
},
"apl_path": "path/to/apl.toml",
},
"parallel_config": {
"enable": "true",
"adjust_char": 2,
"func": "attr_curve", # 可选值功能，后续会拓展
"func_config": { # 根据 func 的值，自动将 func_config 字典转换为正确的模型实例
"sc_range": [0, 40],
"sc_list": ["scATK_percent", "scCRIT", "scCRIT_DMG"],
"remove_equip_list": [],
},
},
}
)
"""
from typing import Literal, Self
from pydantic import (
BaseModel,
Field,
NonNegativeFloat,
NonNegativeInt,
ValidationError,
model_validator,
)
class CharConfig(BaseModel):
"""角色配置参数"""
name: str
CID: int | None = None
weapon: str | None = None
weapon_level: Literal[1, 2, 3, 4, 5] = 1
equip_style: Literal["4+2", "2+2+2"] = "4+2"
equip_set4: str | None = None
equip_set2_a: str | None = None
equip_set2_b: str | None = None
equip_set2_c: str | None = None
drive4: str | None = None
drive5: str | None = None
drive6: str | None = None
scATK_percent: NonNegativeInt = 0
scATK: NonNegativeInt = 0
scHP_percent: NonNegativeInt = 0
scHP: NonNegativeInt = 0
scDEF_percent: NonNegativeInt = 0
scDEF: NonNegativeInt = 0
scAnomalyProficiency: NonNegativeInt = 0
scPEN: NonNegativeInt = 0
scCRIT: NonNegativeInt = 0
scCRIT_DMG: NonNegativeInt = 0
sp_limit: NonNegativeInt | NonNegativeFloat = 120
cinema: Literal[0, 1, 2, 3, 4, 5, 6] = 0
crit_balancing: bool = True
crit_rate_limit: NonNegativeFloat = 0.95
@model_validator(mode="after")
def validate_stats(self) -> Self:
"""验证属性值是否合法"""
# 验证暴击率上限
if not 0.05 <= self.crit_rate_limit <= 1:
raise ValidationError("暴击率上限必须在0.05到1之间")
# 验证所有sc属性必须大于等于0
return self
class EnemyConfig(BaseModel):
"""敌人配置参数"""
index_id: int
adjustment_id: int | str
difficulty: int | float = 8.74
class SimulationConfig(BaseModel):
"""模拟配置参数"""
# all mode common:
stop_tick: int | None = Field(None, description="指定模拟的tick数量")
mode: Literal["normal", "parallel"] | None = Field(None, description="运行模式")
func: Literal["attr_curve", "weapon"] | None = Field(None, description="功能选择")
adjust_char: Literal[1, 2, 3] | None = Field(None, description="调整的角色相对位置")
run_turn_uuid: str | None = Field(None, description="本轮次并行运行的uuid")
class ExecAttrCurveCfg(SimulationConfig):
"""调整副词条配置参数"""
func: Literal["attr_curve", "weapon"] | None = "attr_curve"
sc_name: str
sc_value: int
remove_equip: bool = False
class ExecWeaponCfg(SimulationConfig):
"""调整武器配置参数"""
func: Literal["attr_curve", "weapon"] | None = "weapon"
weapon_name: str
weapon_level: Literal[1, 2, 3, 4, 5]
class CommonCfg(BaseModel):
"""通用配置参数"""
session_id: str
char_config: list[CharConfig] = []
enemy_config: EnemyConfig
apl_path: str = ""
@model_validator(mode="after")
def validate_char_config(self) -> Self:
"""验证角色配置参数"""
# 角色配置参数不能为空
if len(self.char_config) != 3:
raise ValidationError("角色配置参数必须为3个")
return self
class ParallelCfg(BaseModel):
enable: bool = False
adjust_char: Literal[1, 2, 3]
func: Literal["attr_curve", "weapon"] | None = None
func_config: "AttrCurveConfig | WeaponConfig | None" = None
class AttrCurveConfig(BaseModel):
"""调整属性曲线配置参数"""
sc_range: tuple[int, int] = (0, 40)
sc_list: list[str]
remove_equip_list: list[str] = []
class WeaponConfig(BaseModel):
"""调整武器配置参数"""
weapon_list: list["SingleWeapon"] = []
class SingleWeapon(BaseModel):
name: str
level: Literal[1, 2, 3, 4, 5] = 1
ParallelCfg.model_rebuild()
ParallelCfg.WeaponConfig.model_rebuild()
class SessionRun(BaseModel):
"""模拟器会话配置参数，启动会话的全部数据"""
# all mode common:
stop_tick: int | None = Field(None, description="指定模拟的tick数量")
mode: Literal["normal", "parallel"] | None = Field(None, description="运行模式")
common_config: CommonCfg
parallel_config: ParallelCfg | None = None
@model_validator(mode="after")
def validate_common_config(self) -> Self:
"""验证通用配置参数"""
if self.mode == "parallel" and self.parallel_config is None:
raise ValueError("并行模式下，parallel_config 不能为空")
return self
if __name__ == "__main__":
config = ParallelCfg(
enable=True,
adjust_char=2,
func="attr_curve",
func_config={
"sc_range": (0, 40),
"sc_list": ["scATK", "scDEF"],
"remove_equip_list": [],
}, # type: ignore
)
print(config)
try:
session_config = SessionRun(
stop_tick=1000,
mode="parallel",
common_config={
"session_id": "123",
"char_config": [{"name": ""}, {"name": ""}, {"name": ""}],
"enemy_config": {"index_id": 1, "adjustment_id": "s"},
"apl_path": "",
}, # type: ignore
parallel_config=config,
)
print(session_config.model_dump_json(indent=4))
except ValidationError as e:
print(e)
try:
session_config = SessionRun(
**{
"stop_tick": 3600,
"mode": "parallel",
"common_config": {
"session_id": "123",
"char_config": [
{"name": "角色名", "CID": 1},
{"name": "角色名", "CID": 2},
{"name": "角色名", "CID": 3},
],
"enemy_config": {
"index_id": 11451,
"adjustment_id": 22041,
"difficulty": 8.74,
},
"apl_path": "path/to/apl.toml",
},
"parallel_config": {
"enable": "true",
"adjust_char": 2,
"func": "attr_curve", # 可选值功能，后续会拓展
"func_config": { # 根据 func 的值，自动将 func_config 字典转换为正确的模型实例
"sc_range": [0, 40],
"sc_list": ["scATK_percent", "scCRIT", "scCRIT_DMG"],
"remove_equip_list": [],
},
},
}
)
except ValidationError as e:
print(e)
================================================
FILE: zsim/page_apl_editor.py
================================================
import streamlit as st
def page_apl_editor():
st.title("ZZZ Simulator - APL编辑器")
from zsim.lib_webui.process_apl_editor import go_apl_editor
go_apl_editor()
page_apl_editor()
================================================
FILE: zsim/page_character_config.py
================================================
import streamlit as st
import tomli_w
def page_character_config():
st.title("ZZZ Simulator - 角色配置")
from zsim.define import saved_char_config
from zsim.lib_webui.constants import default_chars
if "name_box" in saved_char_config:
default_chars = saved_char_config["name_box"]
from zsim.lib_webui.constants import (
char_profession_map,
equip_set2_options,
equip_set4_options,
profession_chars_map,
weapon_char_map,
weapon_options,
weapon_profession_map,
weapon_rarity_map,
)
col0, col1, col2, col3, col4, col5, col6, col7 = st.columns([1, 1, 1, 1, 1, 1, 1, 1])
with col0:
profession_0 = st.selectbox(
"角色1特性",
list(profession_chars_map.keys()),
index=list(profession_chars_map.keys()).index("不限特性"),
key="profession_select_0",
)
with col1:
name_box_0 = [
st.selectbox(
"角色1",
profession_chars_map[profession_0],
index=profession_chars_map[profession_0].index(default_chars[0])
if len(default_chars) > 0 and default_chars[0] in profession_chars_map[profession_0]
else 0,
key="char_select_0",
)
]
with col3:
profession_1 = st.selectbox(
"角色2特性",
list(profession_chars_map.keys()),
index=list(profession_chars_map.keys()).index("不限特性"),
key="profession_select_1",
)
with col4:
name_box_1 = [
st.selectbox(
"角色2",
profession_chars_map[profession_1],
index=profession_chars_map[profession_1].index(default_chars[1])
if len(default_chars) > 1 and default_chars[1] in profession_chars_map[profession_1]
else 0,
key="char_select_1",
)
]
with col6:
profession_2 = st.selectbox(
"角色3特性",
list(profession_chars_map.keys()),
index=list(profession_chars_map.keys()).index("不限特性"),
key="profession_select_2",
)
with col7:
name_box_2 = [
st.selectbox(
"角色3",
profession_chars_map[profession_2],
index=profession_chars_map[profession_2].index(default_chars[2])
if len(default_chars) > 2 and default_chars[2] in profession_chars_map[profession_2]
else 0,
key="char_select_2",
)
]
name_box = name_box_0 + name_box_1 + name_box_2
if len(name_box) != 3:
st.stop()
if len(name_box) != len(set(name_box)):
st.error("请选择三个不同的角色")
st.stop()
for name in name_box:
with st.expander(f"{name}的配置"):
col_weapon, col_level, col_cinema = st.columns(3)
with col_weapon:
show_adapted_weapon = st.session_state.get(f"{name}_show_adapted_weapon", True)
show_rarity_s = st.session_state.get(f"{name}_show_rarity_s", True)
show_rarity_a = st.session_state.get(f"{name}_show_rarity_a", True)
show_rarity_b = st.session_state.get(f"{name}_show_rarity_b", False)
char_profession = char_profession_map.get(name)
if show_adapted_weapon and char_profession:
filtered_weapon_options = [
w for w in weapon_options if weapon_profession_map.get(w) == char_profession
]
else:
filtered_weapon_options = list(weapon_options)
# 根据稀有度筛选
filtered_weapon_options = [
w
for w in filtered_weapon_options
if (show_rarity_s and weapon_rarity_map.get(w) == "S")
or (show_rarity_a and weapon_rarity_map.get(w) == "A")
or (show_rarity_b and weapon_rarity_map.get(w) == "B")
]
rarity_order = {"S": 0, "A": 1, "B": 2}
filtered_weapon_options = sorted(
filtered_weapon_options,
key=lambda w: (rarity_order.get(weapon_rarity_map.get(w), 3), w),
)
if name in saved_char_config:
current_weapon = saved_char_config[name].get("weapon")
else:
current_weapon = None
# 如果当前音擎不在可选列表，或未设置，则默认选第一个
if not filtered_weapon_options:
st.selectbox(
"音擎",
[],
key=f"{name}_weapon",
)
else:
if current_weapon not in filtered_weapon_options:
current_weapon = filtered_weapon_options[0]
st.selectbox(
"音擎",
filtered_weapon_options,
index=filtered_weapon_options.index(current_weapon),
key=f"{name}_weapon",
format_func=lambda x: (
f"({weapon_rarity_map.get(x, '未知')}"
f"{' ' + weapon_char_map.get(x) if weapon_char_map.get(x) else ''}) {x}"
),
)
col_rarity = st.columns(4)
with col_rarity[0]:
show_adapted_weapon = st.checkbox(
"只显示适配音擎",
value=show_adapted_weapon,
key=f"{name}_show_adapted_weapon",
)
with col_rarity[1]:
show_rarity_s = st.checkbox(
"S",
value=show_rarity_s,
key=f"{name}_show_rarity_s",
)
with col_rarity[2]:
show_rarity_a = st.checkbox(
"A",
value=show_rarity_a,
key=f"{name}_show_rarity_a",
)
with col_rarity[3]:
show_rarity_b = st.checkbox(
"B",
value=show_rarity_b,
key=f"{name}_show_rarity_b",
)
with col_level:
st.number_input(
"音擎精炼等级",
min_value=1,
max_value=5,
value=saved_char_config[name].get("weapon_level", 1)
if name in saved_char_config
else 1,
key=f"{name}_weapon_level",
)
with col_cinema:
st.number_input(
"影画等级",
min_value=0,
max_value=6,
value=saved_char_config[name].get("cinema", 0)
if name in saved_char_config
else 0,
key=f"{name}_cinema_level",
)
equip_style = st.radio(
"驱动盘搭配方式",
["4+2", "2+2+2"],
index=0
if name not in saved_char_config or "equip_style" not in saved_char_config[name]
else (0 if saved_char_config[name]["equip_style"] == "4+2" else 1),
key=f"{name}_equip_style",
)
col1, col2 = st.columns(2)
with col1:
if equip_style == "4+2":
st.selectbox(
"四件套",
equip_set4_options,
index=equip_set4_options.index(saved_char_config[name]["equip_set4"])
if name in saved_char_config and "equip_set4" in saved_char_config[name]
else 0,
key=f"{name}_equip_set4",
)
st.selectbox(
"二件套",
equip_set2_options,
index=equip_set2_options.index(
saved_char_config[name].get("equip_set2_a", "啄木鸟电音")
)
if name in saved_char_config
else 0,
key=f"{name}_equip_set2",
)
else:
st.selectbox(
"二件套A",
equip_set2_options,
index=equip_set2_options.index(
saved_char_config[name].get("equip_set2_a", "啄木鸟电音")
)
if name in saved_char_config
else 0,
key=f"{name}_equip_set2A",
)
st.selectbox(
"二件套B",
equip_set2_options,
index=equip_set2_options.index(
saved_char_config[name].get("equip_set2_b", "啄木鸟电音")
)
if name in saved_char_config and "equip_set2_b" in saved_char_config[name]
else 0,
key=f"{name}_equip_set2B",
)
st.selectbox(
"二件套C",
equip_set2_options,
index=equip_set2_options.index(
saved_char_config[name].get("equip_set2_c", "啄木鸟电音")
)
if name in saved_char_config and "equip_set2_c" in saved_char_config[name]
else 0,
key=f"{name}_equip_set2C",
)
with col2:
from zsim.lib_webui.constants import (
main_stat4_options,
main_stat5_options,
main_stat6_options,
)
st.selectbox(
"四号位主词条",
main_stat4_options,
index=main_stat4_options.index(saved_char_config[name].get("drive4", "攻击力%"))
if name in saved_char_config
else 0,
key=f"{name}_main_stat4",
)
st.selectbox(
"五号位主词条",
main_stat5_options,
index=main_stat5_options.index(saved_char_config[name].get("drive5", "攻击力%"))
if name in saved_char_config
else 0,
key=f"{name}_main_stat5",
)
st.selectbox(
"六号位主词条",
main_stat6_options,
index=main_stat6_options.index(
saved_char_config[name].get("drive6 ", "攻击力%")
)
if name in saved_char_config
else 0,
key=f"{name}_main_stat6",
)
from zsim.lib_webui.constants import sc_max_value
st.text("副词条数量：")
col1, col2, col3, col4, col5 = st.columns(5)
with col1:
st.number_input(
"攻击力%",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scATK_percent", 0)
if name in saved_char_config
else 0,
key=f"{name}_scATK_percent",
)
st.number_input(
"攻击力",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scATK", 0)
if name in saved_char_config
else 0,
key=f"{name}_scATK",
)
with col2:
st.number_input(
"生命值%",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scHP_percent", 0)
if name in saved_char_config
else 0,
key=f"{name}_scHP_percent",
)
st.number_input(
"生命值",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scHP", 0)
if name in saved_char_config
else 0,
key=f"{name}_scHP",
)
with col3:
st.number_input(
"防御力%",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scDEF_percent", 0)
if name in saved_char_config
else 0,
key=f"{name}_scDEF_percent",
)
st.number_input(
"防御力",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scDEF", 0)
if name in saved_char_config
else 0,
key=f"{name}_scDEF",
)
with col4:
st.number_input(
"暴击率",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scCRIT", 0)
if name in saved_char_config
else 0,
key=f"{name}_scCRIT",
)
st.number_input(
"暴击伤害",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scCRIT_DMG", 0)
if name in saved_char_config
else 0,
key=f"{name}_scCRIT_DMG",
)
with col5:
st.number_input(
"异常精通",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scAnomalyProficiency", 0)
if name in saved_char_config
else 0,
key=f"{name}_scAnomalyProficiency",
)
st.number_input(
"穿透值",
min_value=0,
max_value=sc_max_value,
value=saved_char_config[name].get("scPEN", 0)
if name in saved_char_config
else 0,
key=f"{name}_scPEN",
)
col1, col2 = st.columns(2)
with col1:
if name not in saved_char_config:
saved_char_config[name] = {}
crit_balancing: bool = st.checkbox(
"使用暴击配平算法",
value=saved_char_config[name].get("crit_balancing", False),
key=f"{name}_crit_balancing",
)
if st.session_state.get(f"{name}_crit_rate_limit") is None:
st.session_state[f"{name}_crit_rate_limit"] = saved_char_config[name].get(
"crit_rate_limit", 0.95
)
if crit_balancing:
st.number_input(
"暴击率上限",
min_value=0.0,
max_value=1.0,
value=st.session_state[f"{name}_crit_rate_limit"],
key=f"{name}_crit_rate_limit",
help="配平算法会将角色局外面板的暴击率限制在此值以下，适用于会吃到暴击率buff的情况，以防止溢出",
)
char_config = {
"name": name,
"weapon": st.session_state[f"{name}_weapon"],
"weapon_level": st.session_state[f"{name}_weapon_level"],
"cinema": st.session_state[f"{name}_cinema_level"],
"crit_balancing": st.session_state[f"{name}_crit_balancing"],
"crit_rate_limit": st.session_state[f"{name}_crit_rate_limit"],
"scATK_percent": st.session_state[f"{name}_scATK_percent"],
"scATK": st.session_state[f"{name}_scATK"],
"scHP_percent": st.session_state[f"{name}_scHP_percent"],
"scHP": st.session_state[f"{name}_scHP"],
"scDEF_percent": st.session_state[f"{name}_scDEF_percent"],
"scDEF": st.session_state[f"{name}_scDEF"],
"scAnomalyProficiency": st.session_state[f"{name}_scAnomalyProficiency"],
"scPEN": st.session_state[f"{name}_scPEN"],
"scCRIT": st.session_state[f"{name}_scCRIT"],
"scCRIT_DMG": st.session_state[f"{name}_scCRIT_DMG"],
"drive4": st.session_state[f"{name}_main_stat4"],
"drive5": st.session_state[f"{name}_main_stat5"],
"drive6": st.session_state[f"{name}_main_stat6"],
"equip_style": st.session_state[f"{name}_equip_style"],
}
if st.session_state[f"{name}_equip_style"] == "4+2":
char_config["equip_set4"] = st.session_state[f"{name}_equip_set4"]
char_config["equip_set2_a"] = st.session_state[f"{name}_equip_set2"]
else:
char_config["equip_set2_a"] = st.session_state[f"{name}_equip_set2A"]
char_config["equip_set2_b"] = st.session_state[f"{name}_equip_set2B"]
char_config["equip_set2_c"] = st.session_state[f"{name}_equip_set2C"]
st.session_state[f"{name}_config"] = char_config
if not st.button("提交并保存角色配置"):
st.stop()
_config_to_save = {"name_box": name_box}
for name in name_box:
_config_to_save[name] = st.session_state[f"{name}_config"]
saved_char_config.update(_config_to_save)
from zsim.define import char_config_file
with open(char_config_file, "wb") as f:
tomli_w.dump(saved_char_config, f)
from zsim.lib_webui.process_char_config import display_character_panels
display_character_panels(name_box)
page_character_config()
================================================
FILE: zsim/page_data_analysis.py
================================================
import streamlit as st
from zsim.lib_webui.clean_results_cache import (
delete_result,
get_all_results,
rename_result,
)
from zsim.lib_webui.constants import IDDuplicateError
@st.fragment
def _result_manager():
id_cache = get_all_results()
options = list(id_cache.keys())[::-1]
if not options:
st.warning("没有找到任何结果缓存。请先运行模拟器生成结果。", icon="⚠️")
st.stop()
st.markdown("选择一个结果：")
col1, col2, col3, col4 = st.columns(4)
with col1:
selected_key = st.selectbox("选择你要查看的结果", options, label_visibility="collapsed")
with col2:
st.markdown(
f'备注：{id_cache.get(selected_key, "N/A")}', unsafe_allow_html=True, ) with col3: @st.dialog("重命名结果") def rename_dialog(current_key, current_comment): new_name = st.text_input("请输入新的ID", value=current_key) new_comment = st.text_input("请输入新的备注信息", value=current_comment) col1_dialog, col2_dialog = st.columns(2) with col1_dialog: if st.button("保存", key="save_rename", use_container_width=True): try: rename_result(current_key, new_name or "", new_comment or "") st.rerun() except FileNotFoundError: st.warning("请检查文件是否存在或ID是否正确。", icon="⚠️") except IDDuplicateError as e: st.warning(e, icon="⚠️") with col2_dialog: if st.button("取消", key="cancel_rename", use_container_width=True): st.rerun() if st.button("重命名", use_container_width=True): rename_dialog(selected_key, id_cache.get(selected_key, "")) with col4: @st.dialog("删除结果") def delete_dialog(key_to_delete): st.warning(f"你确定要删除 {key_to_delete} 吗？", icon="⚠️") col1_dialog, col2_dialog = st.columns(2) with col1_dialog: if st.button("确定", key="confirm_del_result", use_container_width=True): delete_result(key_to_delete) st.rerun() with col2_dialog: if st.button("取消", key="cancel", use_container_width=True): st.rerun() if st.button("删除", use_container_width=True): delete_dialog(selected_key) return selected_key def page_data_analysis(): from zsim.lib_webui.process_buff_result import show_buff_result from zsim.lib_webui.process_dmg_result import show_dmg_result from zsim.lib_webui.process_parallel_data import ( judge_parallel_result, process_parallel_result, ) st.title("ZZZ Simulator - 数据分析") selected_key = _result_manager() if not st.toggle("开启数据分析"): st.stop() # Ensure selected_key is valid before proceeding if not selected_key: st.error("无法获取选定的结果键。") st.stop() if judge_parallel_result(selected_key): st.write("这是一个并行模式（多进程）的结果。") process_parallel_result(selected_key) else: st.write("这是一个普通模式（单进程）的结果。") show_dmg_result(selected_key) show_buff_result(selected_key) page_data_analysis() ================================================ FILE: zsim/page_simulator.py ================================================ import concurrent.futures import json import os import uuid from typing import Literal import psutil import streamlit as st from zsim.define import NEW_SIM_BOOT, saved_char_config from zsim.lib_webui.constants import stats_trans_mapping, weapon_options from zsim.lib_webui.multiprocess_wrapper import ( run_parallel_simulation, run_single_simulation, ) from zsim.lib_webui.process_char_config import dialog_character_panels from zsim.lib_webui.process_simulator import ( apl_selecter, enemy_selector, generate_parallel_args, save_apl_selection, save_enemy_selection, show_apl_judge_result, ) from zsim.run import go_parallel_subprocess, go_single_subprocess apl_legal = False # --- 常量定义 --- # 模拟器配置相关 RUN_MODES: list[Literal["普通模式（单进程）", "并行模式（多进程）"]] = [ "普通模式（单进程）", "并行模式（多进程）", ] ADJUST_CHAR_OPTIONS = ["1号", "2号", "3号"] SIMULATION_FUNCTIONS = [ "属性收益曲线", "音擎伤害期望对比", "驱动盘四件套对比", "APL对比", "单次失衡爆发对比", "失衡效率对比", "异常积蓄效率对比", ] SC_RANGE_MIN = 0 SC_RANGE_MAX = 75 SC_RANGE_STEP = 1 DEFAULT_SC_RANGE = (0, 75) # 默认模拟词条数范围 DEFAULT_SC_LIST = [] # 默认模拟词条种类 DEFAULT_WEAPON_LIST = [] # 默认武器列表 # UI 相关 TEXT_AREA_HEIGHT = 400 # 结果存储相关 PARALLEL_RUN_PREFIX = "parallel_" RESULTS_DIR_PREFIX = "./results/" PARALLEL_CONFIG_SUFFIX = "/.parallel_config.json" # --- 页面函数 --- def page_simulator(): """模拟器页面函数""" st.title("ZZZ Simulator - 模拟器") from zsim.define import config_path # 获取当前计算机的物理核心数量 MAX_WORKERS = psutil.cpu_count(logical=False) @st.cache_resource def get_executor(): """获取进程池执行器""" return concurrent.futures.ProcessPoolExecutor(max_workers=MAX_WORKERS) with open(config_path, "r", encoding="utf-8") as f: config = json.load(f) default_stop_tick = config["stop_tick"] @st.fragment def go_simulator(): """启动模拟器UI及逻辑""" # 初始化状态 if "simulation_running" not in st.session_state: st.session_state["simulation_running"] = False st.write( '
模拟时长（tick）:
',
unsafe_allow_html=True,
)
st.write("")
col1, col2, col3, col4 = st.columns(4)
with col1:
stop_tick = st.number_input(
"模拟时长",
min_value=1,
max_value=65535,
value=default_stop_tick,
key="stop_tick",
help="单位为 tick（帧），1秒 = 60 ticks",
disabled=st.session_state["simulation_running"],
label_visibility="collapsed",
)
if stop_tick != default_stop_tick:
with open(config_path, "r+", encoding="utf-8") as f:
config = json.load(f)
config["stop_tick"] = stop_tick
f.seek(0)
json.dump(config, f, indent=4)
f.truncate()
# 新增：敌人选择器
st.write("")
st.markdown("**敌人配置**")
# 读取当前保存的敌人配置
enemy_selector()
if st.button("保存敌人配置", disabled=st.session_state["simulation_running"]):
save_enemy_selection(st.session_state["enemy_index"], st.session_state["enemy_adjust"])
st.session_state["enemy_config_unsaved"] = False
with col2:
if st.button(
"查看角色配置",
use_container_width=True,
disabled=st.session_state["simulation_running"],
):
name_box = saved_char_config["name_box"]
dialog_character_panels(name_box)
with col3:
@st.dialog("APL选择", width="large")
def go_apl_select():
"""APL选择对话框"""
selected_title: str = apl_selecter()
show_apl_judge_result(selected_title)
if st.button(
"保存APL选择",
use_container_width=True,
):
save_apl_selection(selected_title)
st.rerun()
if st.button(
"APL选择",
use_container_width=True,
disabled=st.session_state["simulation_running"],
):
go_apl_select()
with col4:
@st.dialog("模拟器配置", width="large")
def go_config():
"""模拟器配置对话框"""
with open(config_path, "r", encoding="utf-8") as f:
config = json.load(f)
parallel_cfg = config["parallel_mode"]
default_mode = parallel_cfg["enabled"]
# st.write(parallel_cfg)
mode = st.radio(
"运行模式",
RUN_MODES,
index=default_mode,
horizontal=True,
)
if mode == RUN_MODES[0]: # 单进程
st.write(
'单进程模式下，模拟器将进行单次模拟。角色配置、模拟时长、APL都有专门的配置项管理，你不需要对此模式进行进行额外配置
', unsafe_allow_html=True, ) elif mode == RUN_MODES[1]: # 多进程 st.write( '多进程模式下，模拟器将按照一定规律执行多次模拟，最大可利用的核心数为你的物理核心数。
', unsafe_allow_html=True, ) # 调整角色的相对位置 default_adjust_char = int(parallel_cfg["adjust_char"]) adjust_char = st.radio( "调整角色", ADJUST_CHAR_OPTIONS, index=default_adjust_char - 1, help="以队伍配置中的顺序进行选择", horizontal=True, ) # 模拟功能 # TODO 添加额外功能后这里需要default_function # Determine the default selected function based on config default_function_index = 0 # Default to the first function if parallel_cfg["adjust_sc"]["enabled"]: default_function_index = SIMULATION_FUNCTIONS.index("属性收益曲线") elif parallel_cfg["adjust_weapon"]["enabled"]: default_function_index = SIMULATION_FUNCTIONS.index("音擎伤害期望对比") selected_func = st.radio( "模拟功能", SIMULATION_FUNCTIONS, index=default_function_index, help="选择模拟功能", horizontal=True, ) if selected_func == SIMULATION_FUNCTIONS[0]: # 属性收益曲线 st.write( '将指定种类的属性按照单个副词条的模型量进行步进增加，分别计算伤害期望
', unsafe_allow_html=True, ) # 模拟范围 default_sc_range_cfg = parallel_cfg["adjust_sc"]["sc_range"] sc_range: tuple[int] = st.slider( "模拟词条数范围", min_value=SC_RANGE_MIN, max_value=SC_RANGE_MAX, value=default_sc_range_cfg, step=SC_RANGE_STEP, ) col_sc_select = st.columns([2, 1]) with col_sc_select[0]: # 模拟词条种类 default_sc_list_cfg = parallel_cfg["adjust_sc"]["sc_list"] # type: ignore sc_list = st.multiselect( "模拟词条种类", stats_trans_mapping.keys(), default=default_sc_list_cfg, help="选择要模拟的词条种类", ) st.write( '右侧选择框的解释：勾选：避免稀释或转模产生影响；不勾选：避免异常/直伤占比变化产生影响；你做不到两全其美一般来说，异常角色带精通主词条就去掉掌控的勾，反之亦然
', unsafe_allow_html=True, ) with col_sc_select[1]: # 控制对应词条是否需要移除其他主副词条 st.write( '清除主副词条开关：
', unsafe_allow_html=True, ) tmp_dict = {} for sc in sc_list: tmp_dict[sc] = st.checkbox( f"{sc}", value=True if sc != "异常掌控" else False, help="勾选后，将在模拟时移除主副词条，不适用于移除装备后会导致词条本身影响输出占比产生变化的情况，一般情况下，你只需要关注异常角色的异常掌控/异常精通", ) remove_equip_list = list( key for key, value in tmp_dict.items() if value ) if "暴击率" in sc_list or "暴击伤害" in sc_list: st.warning( "模拟暴击率/暴击伤害时，建议勾选角色配置中的“使用暴击配平算法”选项", icon="⚠️", ) elif selected_func == SIMULATION_FUNCTIONS[1]: # 音擎伤害期望对比 st.write( '对比不同音擎的伤害期望
', unsafe_allow_html=True, ) # 模拟武器列表 default_weapon_list_cfg = parallel_cfg["adjust_weapon"]["weapon_list"] # Use a list of selectboxes and number inputs for weapon and level weapon_configs = [] st.write("模拟音擎及等级") num_weapons = st.number_input( "音擎数量", min_value=0, value=len(default_weapon_list_cfg), step=1, ) for i in range(num_weapons): col_weapon, col_level = st.columns([3, 1]) with col_weapon: default_weapon_name = ( default_weapon_list_cfg[i]["name"] if i < len(default_weapon_list_cfg) and "name" in default_weapon_list_cfg[i] else weapon_options[0] ) selected_weapon = st.selectbox( f"音擎 {i + 1}", weapon_options, index=( weapon_options.index(default_weapon_name) if default_weapon_name in weapon_options else 0 ), key=f"weapon_select_{i}", label_visibility="collapsed", ) with col_level: default_weapon_level = ( default_weapon_list_cfg[i]["level"] if i < len(default_weapon_list_cfg) and "level" in default_weapon_list_cfg[i] else 1 ) selected_level = st.number_input( f"等级 {i + 1}", min_value=1, max_value=5, value=default_weapon_level, step=1, key=f"weapon_level_{i}", label_visibility="collapsed", ) weapon_configs.append( {"name": selected_weapon, "level": selected_level} ) else: st.error("此功能暂未实现") if st.button("保存配置"): mode_bool = True if mode == RUN_MODES[1] else False # 多进程 if mode_bool: with open(config_path, "r+", encoding="utf-8") as f: config = json.load(f) config["parallel_mode"]["enabled"] = mode_bool config["parallel_mode"]["adjust_char"] = int(adjust_char.split("号")[0]) if selected_func == SIMULATION_FUNCTIONS[0]: # 属性收益曲线 config["parallel_mode"]["adjust_sc"] = { "enabled": True, "sc_range": sc_range, "sc_list": sc_list, "remove_equip_list": remove_equip_list, } config["parallel_mode"]["adjust_weapon"] = { "enabled": False, "weapon_list": DEFAULT_WEAPON_LIST, } elif selected_func == SIMULATION_FUNCTIONS[1]: # 音擎伤害期望对比 config["parallel_mode"]["adjust_sc"] = { "enabled": False, "sc_range": list(DEFAULT_SC_RANGE), "sc_list": DEFAULT_SC_LIST, } config["parallel_mode"]["adjust_weapon"] = { "enabled": True, "weapon_list": weapon_configs, # Save the list of dictionaries } else: config["parallel_mode"]["adjust_sc"] = { "enabled": False, "sc_range": list(DEFAULT_SC_RANGE), "sc_list": DEFAULT_SC_LIST, } config["parallel_mode"]["adjust_weapon"] = { "enabled": False, "weapon_list": DEFAULT_WEAPON_LIST, } f.seek(0) json.dump(config, f, indent=4) f.truncate() else: # 单进程模式 with open(config_path, "r+", encoding="utf-8") as f: config = json.load(f) config["parallel_mode"]["enabled"] = mode_bool f.seek(0) json.dump(config, f, indent=4) f.truncate() st.rerun() if st.button( "模拟器配置", use_container_width=True, disabled=st.session_state["simulation_running"], ): go_config() # 启动模拟后自锁 col1, col2 = st.columns([8, 1]) # 加载config with open(config_path, "r", encoding="utf-8") as f: config = json.load(f) parallel_cfg = config["parallel_mode"] if not parallel_cfg["enabled"]: # 单进程模式 with col1: if ( st.button( "开始模拟-单进程", disabled=st.session_state["simulation_running"] or st.session_state.get("enemy_config_unsaved", False), type="primary", ) and not st.session_state["simulation_running"] ): allow_simulation = show_apl_judge_result() if not allow_simulation: st.error("请先完成APL选择和角色配置") st.stop() st.session_state["simulation_running"] = True st.rerun(scope="fragment") elif not st.session_state["simulation_running"]: st.stop() with st.spinner("单进程模拟中，这可能会持续数十秒，请稍候...", show_time=True): if not NEW_SIM_BOOT: future = get_executor().submit(go_single_subprocess, stop_tick) else: # 使用包装器函数来避免pickle错误 future = get_executor().submit(run_single_simulation, stop_tick) result = future.result() st.text_area( "模拟完成，请前往数据分析查看结果，进程输出：", result, height=TEXT_AREA_HEIGHT, ) st.session_state["simulation_running"] = False elif parallel_cfg["enabled"]: # 多进程模式 st.write( f"多进程模式：模拟{parallel_cfg['adjust_sc']['enabled'] and SIMULATION_FUNCTIONS[0] or '未选择功能'}" ) with col1: if st.button( "开始模拟-多进程", disabled=st.session_state["simulation_running"] or st.session_state.get("enemy_config_unsaved", False), type="primary", ): allow_simulation = show_apl_judge_result() if not allow_simulation: st.error("请先完成APL选择和角色配置") st.stop() st.session_state["simulation_running"] = True st.rerun(scope="fragment") elif not st.session_state["simulation_running"]: st.stop() with st.spinner("多进程模拟中，这可能会持续数十秒，请稍候...", show_time=True): # 每个进程的参数 run_turn_uuid = PARALLEL_RUN_PREFIX + str( uuid.uuid4() ) # 为本轮并行运行生成统一的UUID cfg_dump_dir = RESULTS_DIR_PREFIX + run_turn_uuid + PARALLEL_CONFIG_SUFFIX os.makedirs(os.path.dirname(cfg_dump_dir), exist_ok=True) # 创建结果文件夹 # 将配置存入结果文件根目录 with open(cfg_dump_dir, "w", encoding="utf-8") as f: json.dump(parallel_cfg, f, indent=4) # 启动多进程 if not NEW_SIM_BOOT: futures = { get_executor().submit(go_parallel_subprocess, args): i + 1 for i, args in enumerate( generate_parallel_args( stop_tick, parallel_cfg, run_turn_uuid, ) ) } else: futures = { get_executor().submit(run_parallel_simulation, args): i + 1 for i, args in enumerate( generate_parallel_args( stop_tick, parallel_cfg, run_turn_uuid, ) ) } # 创建结果容器 result_container = st.container() # 实时处理完成的任务 for future in concurrent.futures.as_completed(futures): task_num = futures[future] try: result = future.result() with result_container: with st.expander(f"进程 {task_num} 输出结果"): st.code( result, language="", height=TEXT_AREA_HEIGHT, ) except Exception as e: with result_container: st.error(f"进程 {task_num} 执行出错: {str(e)}") st.session_state["simulation_running"] = False with col2: if st.button("重置模拟器", type="primary", use_container_width=True): st.rerun(scope="fragment") go_simulator() page_simulator() ================================================ FILE: zsim/run.py ================================================ import argparse import subprocess import sys from zsim.simulator.config_classes import SimulationConfig as SimCfg def go_api(): """启动 FastAPI 服务""" try: command = [ sys.executable, "-m", "zsim.api", ] subprocess.run(command) except Exception as e: print(f"错误：启动FastAPI失败 - {str(e)}") sys.exit(1) def go_webui(): """启动 Streamlit 服务""" try: subprocess.run([sys.executable, "-m", "streamlit", "run", "zsim/webui.py"]) except Exception as e: print(f"错误：启动Streamlit失败 - {str(e)}") sys.exit(1) def go_webview_app(): """启动 pywebview 应用。""" try: # 直接执行 webview_app.py 脚本 subprocess.run([sys.executable, "zsim/webview_app.py"], check=True) except subprocess.CalledProcessError as e: print(f"错误：启动 Webview 应用失败 - {e}") sys.exit(1) except FileNotFoundError: print("错误：找不到 zsim/webview_app.py。请确保文件存在。") sys.exit(1) except Exception as e: print(f"错误：启动 Webview 应用时发生未知错误 - {str(e)}") sys.exit(1) def go_cli(): """启动命令行模式，不传递任何参数，用作调试或测试。 Args: `args (MainArgs)`: 包含传递给 main.py 的参数的对象。 默认为一个空的 MainArgs 对象，表示不传递额外参数。 """ try: command = [sys.executable, "zsim/main.py"] subprocess.run(command) except Exception as e: print(f"错误：启动命令行界面失败 - {str(e)}") sys.exit(1) def go_single_subprocess(stop_tick: int): """启动单个子进程""" try: results = [] command = [sys.executable, "zsim/main.py", "--stop-tick", str(stop_tick)] proc = subprocess.run(command, capture_output=True, text=True) results.append(proc.stdout.strip()) return "\n".join(results) except Exception as e: return f"错误：启动子进程失败 - {str(e)}" def go_parallel_subprocess(sim_cfg: SimCfg): """根据提供的 SimCfg 对象启动并行模式子进程。 注意：此函数会强制将 `mode` 参数设置为 `parallel`。 Args: `sim_cfg (SimCfg)`: 包含传递给 main.py 的参数的对象。 其中的 `mode` 参数会被忽略并强制设为 `parallel`。 """ try: command = [sys.executable, "zsim/main.py"] # 强制设置 mode 为 parallel，即使 args 中有其他值 args_dict = sim_cfg.model_dump(exclude_none=True) args_dict["mode"] = "parallel" # 确保 mode 是 parallel for field, value in args_dict.items(): if field == "mode" and value != "parallel": # 跳过非 parallel 的 mode continue if isinstance(value, bool): if value: command.append(f"--{field.replace('_', '-')}") else: command.extend([f"--{field.replace('_', '-')}", str(value)]) # 注意：并行模式可能需要更复杂的处理 proc = subprocess.run(command, capture_output=True, text=True, check=True) return proc.stdout.strip() except subprocess.CalledProcessError as e: return f"错误：启动子进程失败 - {e.stderr}" except Exception as e: return f"错误：启动子进程失败 - {str(e)}" def go_help(): """显示帮助信息""" print("ZZZ模拟器") print("命令列表：") print(" run: 启动 Streamlit WebUI (浏览器)") print(" app: 启动桌面应用 (Webview)") print(" c: 使用 main.py 运行命令行模拟") confirm_launch() def confirm_launch(): """交互式确认启动""" CHOICES = { "run": go_webui, "app": go_webview_app, "c": go_cli, "api": go_api, "help": go_help, } choice = input( "输入 run 启动 WebUI, 输入 app 启动桌面应用, 输入 api 启动API服务, 输入 c 运行命令行：" ).lower() if choice in CHOICES.keys(): CHOICES[choice]() else: print("操作已取消") sys.exit(0) def main(): parser = argparse.ArgumentParser(description="ZZZ Simulator") parser.add_argument( "command", nargs="?", default=None, help="子命令（例如：run, app, c, api）", choices=["run", "app", "c", "api", None], ) args = parser.parse_args() if args.command == "run": go_webui() elif args.command == "app": go_webview_app() elif args.command == "c": go_cli() elif args.command == "api": go_api() else: print("ZZZ模拟器\n") confirm_launch() if __name__ == "__main__": main() ================================================ FILE: zsim/script/APLSpawner/APLDesigner.py ================================================ import gradio as gr from components.SortableRow import SortableRow def create_next_step_interface(): with gr.TabItem("下一步操作", id=1, visible=False) as tab: with gr.Column(): gr.Markdown("## 动态横条配置") # 存储横条数据 rows_state = gr.State(value=[]) # 横条容器 rows_container = gr.HTML() # 控制按钮 with gr.Row(): add_btn = gr.Button("➕ 添加新横条") save_btn = gr.Button("💾 保存配置") # 添加初始化横条 initial_row = SortableRow(1, ["选项A", "选项B"]) rows_container = initial_row.row def add_row(rows): new_id = len(rows) + 1 new_row = SortableRow(new_id, ["选项A", "选项B"]) return new_row.row add_btn.click(fn=add_row, inputs=rows_state, outputs=rows_container) return tab, add_btn, save_btn, rows_state, rows_container ================================================ FILE: zsim/script/APLSpawner/Spawner.py ================================================ import dash import dash_bootstrap_components as dbc import pandas as pd from dash import Dash, Input, Output, dcc, html from zsim.define import CHARACTER_DATA_PATH # 初始化角色数据 char_data = pd.read_csv(CHARACTER_DATA_PATH) full_char_name_list = char_data["name"].tolist() full_char_cid_list = char_data["CID"].tolist() full_char_dict = { name: cid for name, cid in zip(full_char_name_list, full_char_cid_list, strict=False) } class Spawner: def __init__(self): self.full_char_dict = full_char_dict spawner_data = Spawner() app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP]) app.layout = html.Div( [ dcc.Tabs( id="tbas-container", value="char-select-tab", children=[ dcc.Tab( label="角色选择", value="char-select-tab", children=[ dbc.Row( [ dbc.Col( dcc.Dropdown( id="char-select-box-1", options=[ {"label": t[0], "value": t[1]} for t in spawner_data.full_char_dict.items() ], ), md=4, # 每列占4格（Bootstrap共12格） ), dbc.Col( dcc.Dropdown( id="char-select-box-2", options=[ {"label": t[0], "value": t[1]} for t in spawner_data.full_char_dict.items() ], ), md=4, # 每列占4格（Bootstrap共12格） ), dbc.Col( dcc.Dropdown( id="char-select-box-3", options=[ {"label": t[0], "value": t[1]} for t in spawner_data.full_char_dict.items() ], ), md=4, ), ] ), # 第一行 三个角色选择框结束，第二行开始 dbc.Button(), ], ) ], ) ] ) @app.callback( [ Output(component_id="char-select-box-1", component_property="options"), Output(component_id="char-select-box-2", component_property="options"), Output(component_id="char-select-box-3", component_property="options"), ], [ Input(component_id="char-select-box-1", component_property="value"), Input(component_id="char-select-box-2", component_property="value"), Input(component_id="char-select-box-3", component_property="value"), ], prevent_initial_call=True, ) def update_dropdown(char_1, char_2, char_3): """ 回调1：角色选择界面的下拉菜单回调。 根据在下拉菜单中选择的角色，修改其他菜单的内容。 """ """第一步：锁定触发会调函数的源头""" ctx = dash.callback_context """callback_context解释： dash.callback_context输出的内容如下，根据AI的介绍，它输出的应该是JSON格式： { "triggered": [ { "prop_id": "char-select-box_1.value", // 触发源组件ID及属性 "value": "1001", // 触发时的属性值 "triggered": true // 是否实际触发 }, { "prop_id": ".", // 其他可能存在的非主动触发项 "value": null, "triggered": false }] } 所以才需要下面代码的格式整理，最终获取triggered_id """ if not ctx.triggered: raise dash.exceptions.PreventUpdate selected = {val for val in [char_1, char_2, char_3] if val is not None} triggered_id = ctx.triggered[0]["prop_id"].split(".")[0] filtered_options = [] for name, cid in spawner_data.full_char_dict.items(): if cid not in selected: filtered_options.append({"label": name, "value": cid}) else: filtered_options.append({"label": f"{name} (已选)", "value": cid, "disabled": True}) # 仅更新触发源的下拉框 if triggered_id == "char-select-box-1": return filtered_options, dash.no_update, dash.no_update elif triggered_id == "char-select-box-2": return dash.no_update, filtered_options, dash.no_update elif triggered_id == "char-select-box-3": return dash.no_update, dash.no_update, filtered_options else: raise ValueError("触发源ID错误！") @app.callback() def select_char_complete(): """ 回调2：锁定选择按钮回调函数， 主要是判定角色是否完成选择，如果完成选择，那么就开放新的标签页。 """ pass if __name__ == "__main__": app.run_server(debug=True) ================================================ FILE: zsim/script/APLSpawner/__init__.py ================================================ ================================================ FILE: zsim/script/APLSpawner/components/SortableRow.py ================================================ # components/SortableRow.py import gradio as gr class SortableRow: def __init__(self, row_id, options): self.id = row_id with gr.Row(elem_classes="sortable-row") as self.row: self.handle = gr.HTML('☰
')
self.dropdown = gr.Dropdown(options, label=f"选项 {row_id}")
self.delete_btn = gr.Button("❌", elem_classes="delete-btn")
# 删除事件
self.delete_btn.click(fn=lambda: None, inputs=None, outputs=None)
================================================
FILE: zsim/script/code_line.py
================================================
import os
def count_effective_lines(directory):
total_lines = 0
for root, dirs, files in os.walk(directory):
# 排除 .venv 目录
if ".venv" in dirs:
dirs.remove(".venv")
for file in files:
if file.endswith((".py", ".txt", ".c", ".cpp", ".h")):
file_path = os.path.join(root, file)
with open(file_path, "r", encoding="utf-8") as f:
lines = f.readlines()
# 根据文件类型过滤掉空行和注释行
effective_lines: list[str] = []
if file.endswith(".py") or file.endswith(".txt"):
effective_lines = [
line
for line in lines
if line.strip() and not line.strip().startswith("#")
]
elif file.endswith(".c") or file.endswith(".cpp") or file.endswith(".h"):
effective_lines = [
line
for line in lines
if line.strip()
and not line.strip().startswith("//")
and not line.strip().startswith("/*")
]
if effective_lines:
total_lines += len(effective_lines)
return total_lines
def count_total_lines(directory):
total_lines = 0
for root, dirs, files in os.walk(directory):
# 排除 .venv 目录
if ".venv" in dirs:
dirs.remove(".venv")
for file in files:
if file.endswith((".py", ".txt", ".c", ".cpp", ".h")):
file_path = os.path.join(root, file)
with open(file_path, "r", encoding="utf-8") as f:
lines = f.readlines()
total_lines += len(lines)
return total_lines
if __name__ == "__main__":
# 指定目录
directory = "./"
# 计算有效代码行数
effective_lines = count_effective_lines(directory)
print(f"有效代码行数: {effective_lines}")
# 计算总代码行数
total_lines = count_total_lines(directory)
print(f"总代码行数: {total_lines}")
================================================
FILE: zsim/script/del_all_pycache.py
================================================
# 删除指定目录与所有子目录下的__pycache__文件夹
import os
import shutil
def remove_pycache(directory):
for root, dirs, files in os.walk(directory):
print(f"Scanning: {root}")
for dir_name in dirs:
if dir_name == "__pycache__":
pycache_path = os.path.join(root, dir_name)
shutil.rmtree(pycache_path)
print(f"Removed: {pycache_path}")
if __name__ == "__main__":
directory_to_clean = "./"
remove_pycache(directory_to_clean)
================================================
FILE: zsim/script/draw_anomaly_timeline.py
================================================
#!/usr/bin/env python3
"""
绘制异常轴图的脚本。
该脚本读取本地results目录下的damage.csv文件，并根据其中的信息绘制一个透明背景的异常轴图。
启动命令：python zsim/script/draw_anomaly_timeline.py results/359
"""
import argparse
import os
import sys
try:
import pandas as pd
import plotly.express as px
PLOTLY_AVAILABLE = True
except ImportError:
PLOTLY_AVAILABLE = False
print("错误: 缺少必要的依赖包。请安装 pandas 和 plotly:")
print(" pip install pandas plotly")
sys.exit(1)
def find_consecutive_true_ranges(df, column):
"""查找DataFrame列中连续为True的范围。
Args:
df (pd.DataFrame): 输入的DataFrame，需要包含 'tick' 列。
column (str): 要查找的布尔列名。
Returns:
list[tuple[int, int]]: 一个包含 (开始tick, 结束tick) 元组的列表。
"""
ranges = []
start = None
# 获取tick列和指定列的值
ticks = df["tick"].tolist()
values = df[column].tolist()
for i, (tick, value) in enumerate(zip(ticks, values, strict=False)):
if value:
if start is None:
start = tick
else:
if start is not None:
# 结束tick应该是上一个为True的tick
prev_tick = ticks[i - 1] if i > 0 else start
ranges.append((start, prev_tick))
start = None
# 处理最后一个区间（如果存在）
if start is not None:
ranges.append((start, ticks[-1]))
return ranges
def prepare_timeline_data(df):
"""准备用于绘制异常状态时间线的数据。
Args:
df (pd.DataFrame): 原始伤害数据。
Returns:
tuple: (用于绘制Gantt图的DataFrame, 每种异常状态的平均持续时间字典)
"""
required_columns = [
"冻结",
"霜寒",
"畏缩",
"感电",
"灼烧",
"侵蚀",
"烈霜霜寒",
"tick",
]
missing_cols = [col for col in required_columns if col not in df.columns]
if missing_cols:
raise ValueError(f"输入数据缺少必要的列: {missing_cols}")
columns_to_check = ["冻结", "霜寒", "畏缩", "感电", "灼烧", "侵蚀", "烈霜霜寒"]
gantt_data = []
duration_stats = {}
for col in columns_to_check:
if col in df.columns:
ranges = find_consecutive_true_ranges(df, col)
durations = [end - start + 1 for start, end in ranges] # 持续时间包含首尾
duration_stats[col] = durations
for start, end in ranges:
gantt_data.append({"Task": col, "Start": start, "Finish": end})
if not gantt_data:
return pd.DataFrame(), {}
gantt_df = pd.DataFrame(gantt_data)
gantt_df["Duration"] = gantt_df["Finish"] - gantt_df["Start"] + 1 # 持续时间包含首尾
# 计算每种异常状态的平均持续时间
avg_durations = {}
for col, durations in duration_stats.items():
if durations:
avg_durations[col] = sum(durations) / len(durations)
else:
avg_durations[col] = 0
return gantt_df, avg_durations
def draw_anomaly_timeline(gantt_df, output_path=None):
"""绘制异常状态时间线（Gantt图）。
Args:
gantt_df (pd.DataFrame): 用于绘制Gantt图的数据。
output_path (str, optional): 输出图片文件路径（例如 output.png）。
"""
if gantt_df is not None and len(gantt_df) > 0:
fig = px.bar(
gantt_df,
x="Duration",
y="Task",
base="Start",
orientation="h",
labels={
"Start": "开始时间(帧)",
"Duration": "持续时间(帧)",
"Task": "状态类型",
},
height=350,
)
# 设置透明背景
fig.update_layout(
plot_bgcolor="rgba(0,0,0,0)",
paper_bgcolor="rgba(0,0,0,0)",
)
# 设置网格线颜色
fig.update_xaxes(showgrid=True, gridwidth=3, gridcolor="rgba(128,128,128,0.2)")
fig.update_yaxes(showgrid=True, gridwidth=3, gridcolor="rgba(128,128,128,0.2)")
if output_path:
# 保存为PNG图片
try:
fig.write_image(output_path, width=1200, height=300)
print(f"异常轴图已保存至: {output_path}")
except ValueError as e:
if "kaleido" in str(e).lower():
print("错误: 缺少kaleido包，无法保存图片。请安装kaleido:")
print(" pip install kaleido")
print("或者只在浏览器中查看图表，不使用 -o 参数")
sys.exit(1)
else:
raise e
else:
# 在浏览器中显示
fig.show()
else:
print("没有找到任何连续的状态数据")
def main():
parser = argparse.ArgumentParser(description="绘制异常轴图")
parser.add_argument("result_dir", help="战斗日志所在的结果目录，例如 results/123")
parser.add_argument("-o", "--output", help="输出图片文件路径（例如 output.png）")
args = parser.parse_args()
# 如果指定了输出路径，检查kaleido是否可用
if args.output:
try:
import plotly.io as pio
# 尝试导入kaleido
pio.kaleido.scope
except ImportError:
print("警告: 如果要保存图片，请安装kaleido:")
print(" pip install kaleido")
print("否则请只在浏览器中查看图表，不使用 -o 参数")
# 构建damage.csv文件路径
damage_csv_path = os.path.join(args.result_dir, "damage.csv")
# 检查文件是否存在
if not os.path.exists(damage_csv_path):
print(f"错误: 文件 {damage_csv_path} 不存在")
sys.exit(1)
# 读取damage.csv文件
try:
df = pd.read_csv(damage_csv_path)
print(f"成功读取文件: {damage_csv_path}")
except Exception as e:
print(f"读取文件时出错: {e}")
sys.exit(1)
# 准备数据
try:
gantt_df, avg_durations = prepare_timeline_data(df)
print("数据准备完成")
except Exception as e:
print(f"准备数据时出错: {e}")
sys.exit(1)
# 输出每种异常状态的平均持续时间
print("\n各异常状态的平均持续时间:")
print("-" * 30)
for anomaly, avg_duration in avg_durations.items():
if avg_duration == 0:
continue
print(f"{anomaly}: {avg_duration / 60:.2f} 秒")
print("-" * 30)
# 绘制图表
try:
draw_anomaly_timeline(gantt_df, args.output)
print("异常轴图绘制完成")
except Exception as e:
print(f"绘制图表时出错: {e}")
sys.exit(1)
if __name__ == "__main__":
main()
================================================
FILE: zsim/setup.py
================================================
from setuptools import Extension, setup
module_LinkedList = Extension(
"sim_progress.data_struct.LinkedList",
sources=[r"./sim_progress/data_struct/LinkedList.c"],
)
module_ActionStack = Extension(
"sim_progress.data_struct.ActionStack",
sources=[r"./sim_progress/data_struct/ActionStack.cpp"],
)
setup(
name="LinkedList",
version="1.0",
description="A simple linked list extension module",
ext_modules=[module_LinkedList],
)
setup(
name="ActionStack",
version="1.0",
description="A simple action stack extension module",
ext_modules=[module_ActionStack],
)
================================================
FILE: zsim/sim_progress/Buff/Buff0Manager/Buff0ManagerClass.py
================================================
import copy
import itertools
from collections import defaultdict
from typing import TYPE_CHECKING
import pandas as pd
from zsim.define import (
BUFF_0_REPORT,
CHARACTER_DATA_PATH,
EXIST_FILE_PATH,
JUDGE_FILE_PATH,
saved_char_config,
)
from .. import JudgeTools
from ..buff_class import Buff
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class Buff0Manager:
def __init__(
self,
name_box: list[str],
judge_list_set: list[list[str]],
weapon_dict: dict[str, list],
cinema_dict: dict,
char_obj_dict: dict | None,
sim_instance: "Simulator | None",
):
# 加载文件
self.EXIST_FILE = pd.read_csv(EXIST_FILE_PATH, index_col="BuffName")
self.JUDGE_FILE = pd.read_csv(JUDGE_FILE_PATH, index_col="BuffName")
self.CHARACTER_FILE = pd.read_csv(CHARACTER_DATA_PATH, index_col="name")
self.sim_instance: "Simulator" = sim_instance
self.judge_list_set = judge_list_set
self.weapon_dict = weapon_dict
self.cinema_dict = cinema_dict
self.char_name_box = name_box # 角色名列表
self.name_order_box = self.change_name_box() # 角色名顺序字典
self.char_obj_dict = char_obj_dict
self.buff_info_inventory: dict[str, dict[str, tuple[dict, dict]]] = defaultdict(dict)
# 设置初始值和数据预处理
self.allbuff_list = self.EXIST_FILE.index.tolist() # 将索引列转为列表
self.buff_name_box: dict[str, list[str]] = {}
# 初始化exist_buff_dict
self.exist_buff_dict: dict[str, dict[str, Buff]] = {"enemy": {}}
for _char_name in self.char_name_box:
self.exist_buff_dict[_char_name] = {}
# 把处理judge_list_set
self.__equip_set2_box = []
self.char_equip_info: dict[str, dict[str, str]] = {}
self.__process_judge_list_set()
self.total_judge_condition_list = (
list(itertools.chain.from_iterable(self.judge_list_set)) + self.__equip_set2_box
)
self.__selector = self.__selector(self)
self.__selector.select_buff_into_exist_buff_dict()
self.__passively_updating_change()
# self.__process_label()
"""
由于deepcopy存在问题，导致buff_0这里初始化好的only_active_by参数在后续复制的过程中可能丢失，
所以这里索性不做处理，直接到data_struct中现场处理。
"""
self.__process_additional_ability_data()
# self.initialize_buff_listener()
if BUFF_0_REPORT:
print(self)
def __str__(self):
output = ""
for _char_name, _sub_dict in self.exist_buff_dict.items():
output += f"本次模拟中{_char_name}可能吃到的Buff为：\n"
for _i in _sub_dict.values():
output += f" {_i.ft.index}\n"
return output
def initialize_buff_listener(self):
"""处理buff监听器的初始化"""
for _char_name, _sub_dict in self.exist_buff_dict.items():
for _buff_0 in _sub_dict.values():
if not isinstance(_buff_0, Buff):
raise TypeError(f"存在非Buff类型的对象：{_buff_0}")
if _buff_0.ft.listener_id is not None:
_obj = (
self.char_obj_dict[_buff_0.ft.operator]
if _buff_0.ft.operator != "enemy"
else self.sim_instance.schedule_data.enemy
)
self.sim_instance.listener_manager.listener_factory(
listener_owner=_obj,
initiate_signal=_buff_0.ft.listener_id,
sim_instance=self.sim_instance,
)
def __process_label(self):
"""处理label类型的内容"""
for _char_name, _dict in self.exist_buff_dict.items():
for _index, _buff_0 in _dict.items():
if not _buff_0.ft.label:
continue
if (
"only_active_by" in _buff_0.ft.label
and _buff_0.ft.label["only_active_by"][0] == "self"
):
char_obj = JudgeTools.find_char_from_name(
_buff_0.ft.operator, sim_instance=self.sim_instance
)
_buff_0.ft.label["only_active_by"] = [char_obj.CID]
def __process_judge_list_set(self):
"""将judge_list_set中的信息全部处理到self.char_equip_info 中"""
for _sub_list in self.judge_list_set:
_name = _sub_list[0]
_weapon = _sub_list[1]
_equip_set4 = _sub_list[2]
_equip_set2_a = _sub_list[3]
if saved_char_config[_name]["equip_style"] == "4+2":
self.char_equip_info[_name] = {
"weapon": _weapon,
"equip_set4": _equip_set4,
"equip_set2_a": _equip_set2_a,
"equip_style": "4+2",
}
elif saved_char_config[_name]["equip_style"] == "2+2+2":
_equip_set2_b = saved_char_config[_name]["equip_set2_b"]
_equip_set2_c = saved_char_config[_name]["equip_set2_c"]
self.char_equip_info[_name] = {
"weapon": _weapon,
"equip_set4": None,
"equip_set2_a": _equip_set2_a,
"equip_set2_b": _equip_set2_b,
"equip_set2_c": _equip_set2_c,
"equip_style": "2+2+2",
}
self.__equip_set2_box.append(_equip_set2_b)
self.__equip_set2_box.append(_equip_set2_c)
else:
raise ValueError("无法解析的驱动盘装备策略！")
def __process_additional_ability_data(self):
"""修改角色对象的组队被动激活参数"""
for _char_name, sub_exist_dict in self.exist_buff_dict.items():
if _char_name == "enemy":
continue
char_instance = self.char_obj_dict[_char_name]
for _buff_index, _buff_instance in sub_exist_dict.items():
if (
_buff_instance.ft.is_additional_ability
and _char_name == _buff_instance.ft.bufffrom
):
char_instance.additional_abililty_active = True
break
else:
char_instance.additional_abililty_active = False
# print(char_instance.NAME, char_instance.additional_abililty_active)
def change_name_box(self):
"""
生成每个角色对应的namebox列表，以自己作为第0位角色。
举例：
name_box = [苍角，艾莲，莱卡恩]
name_order_dict = {
苍角：[苍角，艾莲，莱卡恩，enemy],
艾莲：[艾莲，莱卡恩，苍角，enemy],
莱卡恩：[莱卡恩，苍角，艾莲，enemy]
}
"""
name_box = self.char_name_box
output_name_dict = {}
for i in range(len(name_box)):
new_name_box = name_box[i:] + name_box[:i]
output_name_dict[name_box[i]] = new_name_box + ["enemy"]
return output_name_dict
def __passively_updating_change(self):
"""完成初始化之前，进行最后的参数调整。"""
for char_name, sub_buff_dict in self.exist_buff_dict.items():
for _buff_0 in sub_buff_dict.values():
if not isinstance(_buff_0, Buff):
raise TypeError
if char_name == "enemy":
_buff_0.ft.passively_updating = False
else:
if _buff_0.ft.operator != char_name:
_buff_0.ft.passively_updating = True
else:
_buff_0.ft.passively_updating = False
def search_equipper(self, equipment: str) -> str | None:
"""
根据输入的装备名称寻找装备者
临时使用，该函数只能返回找到的第一个，
buff系统重构后将重写此逻辑
"""
for _char_name, sub_list in self.weapon_dict.items():
if sub_list[0] == equipment:
return _char_name
else:
return None
class __selector:
def __init__(self, buff_0_manager_instance):
self.buff_0_manager: Buff0Manager = buff_0_manager_instance
self.__select_strategy_map = {
"char_handler": None,
"weapon_handler": None,
"drive_handler": None,
}
self.__special_set2_dict = {"如影相随": ["Buff-驱动盘-如影相随-二件套"]}
self.__buff_0_pool: dict[str, tuple] = {}
self.__additional_ability_data = self.__additional_ability_data(self.buff_0_manager)
self.__get_buff_0_pool()
class __additional_ability_data:
"""组队被动数据，主要负责组队被动激活相关"""
def __init__(self, buff_0_manager_instance):
self.buff_0_manager: Buff0Manager = buff_0_manager_instance
self.condition_list = [
"角色属性-中文",
"角色阵营",
"角色特性",
"支援类型",
]
self.additional_ability_judge_info = {}
self.__get_additional_ability_judge_info()
# print(self.additional_ability_judge_info)
def __get_additional_ability_judge_info(self):
for _char_name in self.buff_0_manager.char_name_box:
sub_info_list = []
self.additional_ability_judge_info[_char_name] = {}
self.additional_ability_judge_info[_char_name]["required_condition"] = (
self.buff_0_manager.CHARACTER_FILE.loc[_char_name, "组队被动条件"]
)
for condition in self.condition_list:
sub_info_list.append(
self.buff_0_manager.CHARACTER_FILE.loc[_char_name, condition]
)
self.additional_ability_judge_info[_char_name]["config_info"] = sub_info_list
def addition_skill_info_trans(self, buff_from: str):
"""
前置函数的初始化会将组队被动的激活条件原封不动地放入字典中（包含|分隔符的字符串）
此函数是将字符串根据分隔符分割成list，并且根据具体内容进行翻译，
最后输出的是翻译后的list。
例如：苍角的组队被动激活条件是‘同属性|同阵营’
那么翻译过后就会输出：
['冰', '对空6课']
"""
addition_skill_info = self.additional_ability_judge_info[buff_from]
required_condition_list = addition_skill_info["required_condition"].split("|")
condition_list_after_trans = []
for conditions in required_condition_list:
if conditions == "同阵营":
condition_list_after_trans.append(addition_skill_info["config_info"][1])
elif conditions == "同属性":
condition_list_after_trans.append(addition_skill_info["config_info"][0])
elif conditions in ["异常", "强攻", "支援", "击破", "防护", "命破"]:
condition_list_after_trans.append(conditions)
elif conditions in ["招架", "回避"]:
condition_list_after_trans.append(conditions)
else:
raise ValueError(f"无法解析的组队被动激活条件：{conditions}")
return condition_list_after_trans
def __get_buff_0_pool(self):
"""筛选出总的buff_0池子。"""
# 遍历 EXIST_FILE，按条件筛选
for buff_name, row_data in self.buff_0_manager.EXIST_FILE.iterrows():
# 判断是否符合所有筛选条件
buff_from = row_data["from"]
if row_data["is_weapon"]:
"""武器Buff"""
for charname in self.buff_0_manager.weapon_dict:
if (
buff_from == self.buff_0_manager.weapon_dict[charname][0]
and row_data["refinement"]
== self.buff_0_manager.weapon_dict[charname][1]
):
self.select_buffs(buff_name, row_data)
elif row_data["is_cinema"] and buff_from in self.buff_0_manager.cinema_dict.keys():
"""影画Buff"""
if row_data["refinement"] <= self.buff_0_manager.cinema_dict[buff_from]:
self.select_buffs(buff_name, row_data)
else:
"""角色Buff 和 Enemy"""
if buff_from in self.buff_0_manager.weapon_dict:
"""组队被动"""
if row_data["is_additional_ability"]:
"""获得【足以使组队被动激活的条件集合】"""
condition_list_after_trans = (
self.__additional_ability_data.addition_skill_info_trans(buff_from)
)
partner_condition_list = []
for (
other_key
) in self.__additional_ability_data.additional_ability_judge_info:
if other_key != buff_from:
partner_condition_list.extend(
self.__additional_ability_data.additional_ability_judge_info[
other_key
]["config_info"]
)
# print(buff_name, condition_list_after_trans, partner_condition_list)
for conditions in condition_list_after_trans:
if conditions in partner_condition_list:
self.select_buffs(buff_name, row_data)
break
else:
if buff_from in self.buff_0_manager.char_name_box:
self.select_buffs(buff_name, row_data)
elif row_data["from"] == "enemy":
self.select_buffs(buff_name, row_data)
else:
if buff_from in self.buff_0_manager.total_judge_condition_list:
self.select_buffs(buff_name, row_data)
def select_buffs(self, buff_name, row_data):
"""
根据buffname为索引，去dataframe中寻找对应的judge，并且和输入的rowdata打包进入selected buffs
"""
judge_row_data = self.buff_0_manager.JUDGE_FILE.loc[buff_name]
row_data["BuffName"] = buff_name
self.__buff_0_pool[buff_name] = (row_data, judge_row_data)
def select_buff_into_exist_buff_dict(self):
for buff_name, buff_info_tuple in self.__buff_0_pool.items():
buff_from = buff_info_tuple[0]["from"]
try:
adding_code = str(int(buff_info_tuple[0]["add_buff_to"])).zfill(4)
except ValueError:
raise ValueError(f"{buff_name}的 add_buff_to 参数填写不完整！")
if buff_from in self.buff_0_manager.char_name_box:
"""如果buff来自于角色，那么buff_from就一定指向这个buff的真正来源，也就是buff的拥有者（并非buff的受益者）"""
current_name_box = self.buff_0_manager.name_order_box[buff_from]
selected_characters = [
current_name_box[i]
for i in range(len(current_name_box))
if adding_code[i] == "1"
]
if buff_from not in selected_characters:
selected_characters.append(buff_from)
for _name in selected_characters:
self.initiate_buff(buff_info_tuple, buff_name, _name, buff_from)
elif buff_from == "enemy":
"""
进入这一分支的所有buff实际上都是环境或是其他原因而强加给enemy的，
由于buffload函数并不会以“enemy”为主视角来判定buff，
所有添加给enemy的buff都是在buffload遍历其他角色时产生、或是其他阶段强行添加的，
所以，此处的buff_orner参数传入并不严格，因为用不到。
"""
self.initiate_buff(buff_info_tuple, buff_name, "enemy", "enemy")
elif buff_from in self.buff_0_manager.total_judge_condition_list:
"""
如果buff不属于角色和enemy，那么buff肯定来自装备。
"""
for (
char_name,
_sub_equip_info_dict,
) in self.buff_0_manager.char_equip_info.items():
if buff_from in _sub_equip_info_dict.values():
self.processor_equipment_buff(
adding_code, buff_info_tuple, buff_name, char_name
)
def initiate_buff(self, buff_info_tuple, buff_name, benifiter, buff_orner):
"""
参数中的benifiter和orner不是一个名字。benifiter是buff的受益者，但并不一定是触发buff的角色。
而buff_orner是触发buff者，哪怕这个buff是加给别人的，作为触发者，它的exist_buff_dict中也应该保留这个buff，
这样，在BuffLoad函数对buff_0进行判断时，就可以通过buff.ft.passively_updating参数来避开不必要的判断了。
"""
dict_1 = copy.deepcopy(buff_info_tuple[0]) # 创建 dict_1 的副本
dict_2 = copy.deepcopy(buff_info_tuple[1]) # 创建 dict_2 的副本
dict_1["operator"] = buff_orner
if benifiter == buff_orner:
dict_1["passively_updating"] = False
else:
dict_1["passively_updating"] = True
buff_new = Buff(dict_1, dict_2, sim_instance=self.buff_0_manager.sim_instance)
buff_new.ft.beneficiary = benifiter
self.buff_0_manager.exist_buff_dict[benifiter][buff_name] = buff_new
# self.buff_0_manager.buff_info_inventory[benifiter][buff_name] = (dict_1, dict_2)
def processor_equipment_buff(
self, adding_code, buff_info_tuple, buff_name, equipment_carrier
):
"""处理来源于装备的Buff"""
""" 为了防止只佩戴了二件套的情况下，筛选出了拥有相同buff_from的四件套效果，之类需要进行额外的判断。"""
current_name_box = self.buff_0_manager.name_order_box[equipment_carrier]
personal_equip_dict = self.buff_0_manager.char_equip_info[equipment_carrier]
buff_from = buff_info_tuple[0]["from"]
if personal_equip_dict["equip_style"] == "4+2":
if (
personal_equip_dict["equip_set2_a"] in buff_name
and personal_equip_dict["equip_set2_a"] not in self.__special_set2_dict
):
"""
如果检测到装备者选择配装风格是4+2，并且装备者二件套的名字出现在Buff名中，
就说明是出现了“只佩戴了二件套但是错误地筛选出了四件套的情况”，
此时能够进入这一分支的情况有两种：
1、二件套确实附带了一个Buff——如影2，那么这个Buff就一定在__selector的豁免名单中。
2、二件套并未附带Buff，但是因为和四件套拥有相同的buff_from，所以错误地进入了这个分支，需要处理的，也正是这个分支。
"""
return
elif personal_equip_dict["equip_style"] == "2+2+2":
"""当配装方案是2+2+2时，只要当前任意的二件套处于豁免范围，"""
if "四件套" in buff_name:
return
"""筛除所有和豁免名单无关的套装，无论4、2件套；然后再筛除不在豁免名单上的二件套Buff"""
if not (
buff_from in self.__special_set2_dict
and buff_name in self.__special_set2_dict[buff_from]
):
return
selected_characters = [
current_name_box[i] for i in range(len(current_name_box)) if adding_code[i] == "1"
]
if equipment_carrier not in selected_characters:
selected_characters.append(equipment_carrier)
for _name in selected_characters:
self.initiate_buff(buff_info_tuple, buff_name, _name, equipment_carrier)
def change_name_box(name_box):
"""
生成每个角色对应的namebox列表，以自己作为第0位角色
"""
output_name_dict = {}
for i in range(len(name_box)):
new_name_box = name_box[i:] + name_box[:i]
output_name_dict[name_box[i]] = new_name_box + ["enemy"]
return output_name_dict
================================================
FILE: zsim/sim_progress/Buff/Buff0Manager/__init__.py
================================================
from .Buff0ManagerClass import Buff0Manager, change_name_box
__all__ = ["Buff0Manager", "change_name_box"]
================================================
FILE: zsim/sim_progress/Buff/BuffAdd.py
================================================
from .buff_class import Buff
def buff_add(timenow: float, LOADING_BUFF_DICT: dict, DYNAMIC_BUFF_DICT: dict, enemy):
"""
该函数是Buff三部曲中的最后一步。
它负责把LOADING_BUFF_DICT中的待加载的buff添加到对应角色的Dynamic_Buff_List中，
由于load阶段存在一个小漏洞，导致当前动作中，一些因hit激活的buff，会在start节点漏进来:
前提：LOAD阶段的这个漏洞系底层逻辑缺陷，无法在LOAD阶段自己解决，只能后面的程序进行找补。
Bug成因：
原因是在start那个ticks的BuffLoadLoop函数会因为主要参数对比全部通过，放行这个本不该在start标签处触发的buff。
举例：
这个Buff是普攻触发，那么普攻的第一帧（start)，虽然还没有hit，但确实是“正在进行普攻”状态，那么这个buff就是会通过判断。
该buff会顺利进入LOADING_BUFF_DICT从而被ADD函数无脑执行，添加进DYNAMIC_BUFF_DICT中。
但是每个buff在添加进DYNAMIC之前，都要执行buff.update方法来更新自身的动态信息（幸亏我当时很菜，把buff实例化和更新信息分开写了！！）
而该buff会因为当前子任务是start而被归入start分支，从而执行update_cause_start函数，
但是该buff本身是hit更新类型，所以无法进入start函数的任意一个分支，也就无法获得时间等动态信息的有效更新。
也就是说，BuffLoadLoop会放行一些buff，这些buff会被实例化，但是时间、层数等完全不会更新，全部是0，actrive状态也是False。
在下一个tick，这些buff会因为自身endticks小于当前tick，而被Update_Buff函数扫出DYNAMIC_BUFF_DICT
我记得之前遇到过的“灵异事件”，就是在tick=1的时候，会发现出现了一些没有信息更新的buff，它们漏进了Dynamic_buff_dict，但是在tick=2时消失，也正是因为这个原因。
虽然这些漏进去的Buff只会存在一个Ticks，但是也很有可能影响当前tick的计算。
所以，在后续处理DynamicBuffList时，需要schedule阶段多判断一个buff.dy.active 是否是True，如果不是True就不要执行。
或者，在Buff_Add阶段处理，判断一下active或是buff.dy下面的任意属性是否为0即可。
所以，LOADING_BUFF_DICT中只会出现本tick该被添加的buff，将所有buff全部add，将容器清空是这个阶段的核心任务。
所有的buff都会被添加到对应的DYNAMIC_BUFF_DICT中，这样一来，“加buff”这一动作被彻底实现。
"""
for char in LOADING_BUFF_DICT:
if not LOADING_BUFF_DICT[char]:
continue
while LOADING_BUFF_DICT[char]:
buff = LOADING_BUFF_DICT[char].pop()
# for buff in LOADING_BUFF_DICT[char]:
if not isinstance(buff, Buff):
raise ValueError(f"loading_buff_dict中的{buff}元素不是Buff类")
if (
not buff.dy.active
or (buff.dy.startticks == 0 and buff.dy.endticks == 0)
or buff.dy.count == 0
):
# if buff.ft.index == 'Buff-武器-精1燃狱齿轮-叠层冲击力':
# print(f'{buff.dy.active, buff.dy.startticks, buff.dy.endticks, buff.dy.count}')
continue
buff_existing_check = next(
(
existing_buff
for existing_buff in DYNAMIC_BUFF_DICT[char]
if existing_buff.ft.index == buff.ft.index
),
None,
)
# 这个语句的作用是，检查buff是否已经存在。检查的索引是buff.ft.index。
if buff_existing_check:
if buff.ft.alltime:
continue
DYNAMIC_BUFF_DICT[char].remove(buff_existing_check)
# report_to_log(f'[Buff ADD]:{timenow}:{buff_existing_check.ft.name}刷新了')
DYNAMIC_BUFF_DICT[char].append(buff)
add_debuff_to_enemy(buff, char, enemy)
return DYNAMIC_BUFF_DICT
def add_debuff_to_enemy(buff, char, enemy):
if char == "enemy":
debuff_existing_check = next(
(
existing_buff
for existing_buff in enemy.dynamic.dynamic_debuff_list
if existing_buff.ft.index == buff.ft.index
),
None,
)
if debuff_existing_check:
enemy.dynamic.dynamic_debuff_list.remove(debuff_existing_check)
enemy.dynamic.dynamic_debuff_list.append(buff)
# 只有在处理enemy的buff时，需要将改动同时同步到buff中。
# report_to_log(f'[Buff ADD]:{timenow}:{buff.ft.name}第{buff.history.active_times}次触发:endticks:{buff.dy.endticks}')
================================================
FILE: zsim/sim_progress/Buff/BuffAddStrategy.py
================================================
from typing import TYPE_CHECKING
from .buff_class import Buff
if TYPE_CHECKING:
from zsim.sim_progress.Enemy import Enemy
from zsim.simulator.simulator_class import Simulator
def _buff_filter(*args, **kwargs):
buff_name_list: list[str] = []
for arg in args:
if isinstance(arg, str):
buff_name_list.append(arg)
elif isinstance(arg, Buff):
buff_name_list.append(arg.ft.index)
for value in kwargs.values():
if isinstance(value, str):
buff_name_list.append(value)
if isinstance(value, Buff):
buff_name_list.append(value.ft.index)
return buff_name_list
def buff_add_strategy(
*added_buffs: str | Buff,
benifit_list: list[str] | None = None,
specified_count: int | float | None = None,
sim_instance: "Simulator" = None,
):
"""
这个函数是暴力添加buff用的，比如霜寒、畏缩等debuff，
又比如核心被动强行添加buff的行为，都可以通过这个函数来实现。
Args:
added_buffs: str: 需要添加的Buff的index
benifit_list: list[str]: 受益者名单
specified_count: int | float | None: 指定层数，非必要参数
sim_instance: Simulator: 模拟器实例
"""
if sim_instance is None:
raise ValueError("调用buff_add_strategy函数时，sim_instance是None")
buff_name_list: list[str] = _buff_filter(*added_buffs)
all_name_order_box = sim_instance.load_data.all_name_order_box
# name_box = main_module.load_data.name_box
# name_box_now = name_box + ['enemy']
enemy = sim_instance.schedule_data.enemy
exist_buff_dict = sim_instance.load_data.exist_buff_dict
tick = sim_instance.tick
DYNAMIC_BUFF_DICT = sim_instance.global_stats.DYNAMIC_BUFF_DICT
"""
将Buff名称、Buff实例转化为对应的Buff并且添加到DYNAMIC_BUFF_DICT或者其他地方。
是在Load阶段以外暴力互动DYNAMIC_BUFF_DICT的通用方式。
"""
# 对于buff_name_list中的每个Buff都执行一次
for buff_name in buff_name_list:
# FIXME: 这里可能存在Bug，指定受益人（benifit_list）可能与自动查找的逻辑冲突。
selected_characters = confirm_selected_character(
exist_buff_dict, buff_name, all_name_order_box, benifit_list
)
if selected_characters is None:
print(
f"【BuffAddStrategy警告】并未找到适用于{buff_name}的受益人！本次Buff添加将被跳过！"
)
continue
# 针对每位受益人，都执行一次Buff添加
for names in selected_characters:
let_buff_start(
DYNAMIC_BUFF_DICT, buff_name, enemy, exist_buff_dict, names, specified_count, tick
)
# __check_buff_add_result(buff_name, selected_characters, exist_buff_dict, DYNAMIC_BUFF_DICT, sim_instance)
def let_buff_start(
DYNAMIC_BUFF_DICT: dict[str, list[Buff]],
buff_name: str,
enemy: "Enemy",
exist_buff_dict: dict[str, dict[str, Buff]],
names: str,
specified_count: int,
tick: int,
):
"""
这个函数是buff_add_strategy函数的添加Buff的核心业务函数。
Args:
DYNAMIC_BUFF_DICT: dict: 动态Buff字典
buff_name: str: Buff名称
enemy: Character: 敌人
exist_buff_dict: dict: 存在的Buff字典
names: str: 受益者名称
specified_count: int | float | None: 指定层数，非必要参数
tick: int: 当前时间
"""
from copy import deepcopy
# 对于不同的Buff受益人，sub_exist_buff_dict是不同的，需要重新获取
sub_exist_buff_dict = exist_buff_dict[names]
copyed_buff = sub_exist_buff_dict[buff_name]
buff_new = deepcopy(copyed_buff)
buff_new.ft.operator = copyed_buff.ft.operator
buff_new.ft.passively_updating = copyed_buff.ft.passively_updating
buff_new.ft.beneficiary = copyed_buff.ft.beneficiary
# buff_new = Buff.create_new_from_existing(copyed_buff)
if copyed_buff.ft.simple_start_logic and buff_new.ft.simple_effect_logic:
if specified_count is not None:
buff_new.simple_start(
tick,
sub_exist_buff_dict,
specified_count=specified_count,
)
else:
buff_new.simple_start(tick, sub_exist_buff_dict)
elif not copyed_buff.ft.simple_start_logic:
# print(buff_new.ft.index)
buff_new.logic.xstart(benifit=names)
elif not copyed_buff.ft.simple_effect_logic:
# print(buff_new.ft.index)
buff_new.logic.xeffect()
# 更新 DYNAMIC_BUFF_DICT
dynamic_buff_list = DYNAMIC_BUFF_DICT.get(names, [])
buff_existing_check = next(
(
existing_buff
for existing_buff in dynamic_buff_list
if existing_buff.ft.index == buff_new.ft.index
),
None,
)
if buff_existing_check:
dynamic_buff_list.remove(buff_existing_check)
# print(f'强制添加Buff函数执行，本次为 {names} 添加的Buff为：{buff_new.ft.index}，激活状态为：{buff_new.dy.active}，开始时间为：{buff_new.dy.startticks}，结束时间为：{buff_new.dy.endticks}，层数：{buff_new.dy.count}')
dynamic_buff_list.append(buff_new)
# 如果是敌人，更新动态 Debuff 列表
if names == "enemy":
enemy_dynamic_debuff_list = enemy.dynamic.dynamic_debuff_list
debuff_existing_check = next(
(
existing_buff
for existing_buff in enemy_dynamic_debuff_list
if existing_buff.ft.index == buff_new.ft.index
),
None,
)
if debuff_existing_check:
enemy_dynamic_debuff_list.remove(debuff_existing_check)
enemy_dynamic_debuff_list.append(buff_new)
def get_selected_character(adding_buff_code, all_name_order_box, copyed_buff):
if copyed_buff.ft.add_buff_to == "0001" or copyed_buff.ft.operator == "enemy":
selected_characters = ["enemy"]
else:
name_box_now = all_name_order_box[copyed_buff.ft.operator]
selected_characters = [
name_box_now[i] for i in range(len(name_box_now)) if adding_buff_code[i] == "1"
]
return selected_characters
def confirm_selected_character(
exist_buff_dict: dict[str, dict[str, Buff]],
buff_name: str,
all_name_order_box: dict[str, list[str]],
benifit_list: list[str] = None,
) -> list[str] | None:
"""
确认选中的角色是否存在。
Args:
exist_buff_dict: dict[str,dict[str,Buff]]: 存在Buff字典
buff_name: str: 即将执行强行添加的Buff名称
all_name_order_box: dict[str, list[str]]: 所有角色的名称列表
benifit_list: list[str]: 外部制定的受益者名单
"""
for char_name, sub_dict in exist_buff_dict.items():
# 首先判断Buff是否在当前检查角色(char_name)的收益列表中
if buff_name not in sub_dict:
continue
selected_buff = sub_dict[buff_name]
# assert isinstance(selected_buff, Buff), "buff_add_strategy函数中，buff_name_list中的元素必须是Buff类"
# 确定本次Buff添加的受益人
adding_buff_code = str(int(selected_buff.ft.add_buff_to)).zfill(4)
selected_characters = (
get_selected_character(adding_buff_code, all_name_order_box, selected_buff)
if benifit_list is None
else benifit_list
)
return selected_characters
else:
return None
def __check_buff_add_result(
buff_name: str,
selected_characters: list[str],
exist_buff_dict: dict[str, dict[str, Buff]],
DYNAMIC_BUFF_DICT: dict[str, list[Buff]],
sim_instance: "Simulator",
):
"""
检查Buff添加结果是否符合预期。
Args:
buff_name: str: 即将执行强行添加的Buff名称
selected_characters: list[str]: 选中的角色列表
exist_buff_dict: dict[str,dict[str,Buff]]: 存在Buff字典
DYNAMIC_BUFF_DICT: dict[str, list[Buff]: 动态Buff字典
"""
tick = sim_instance.tick
for char_name in selected_characters:
sub_list = DYNAMIC_BUFF_DICT[char_name]
for buffs in sub_list:
assert isinstance(buffs, Buff)
buff_0 = exist_buff_dict[char_name][buffs.ft.index]
if buffs.ft.index == buff_name:
if all(
[
buffs.dy.startticks == buff_0.dy.startticks,
buffs.dy.endticks == buff_0.dy.endticks,
buffs.dy.count == buff_0.dy.count,
]
):
print(
f"【BuffAddStrategy检查】{tick}tick：{char_name}成功添加了{buff_name}, 其层数为{buffs.dy.count}，{buffs.dy.startticks} - {buffs.dy.endticks}"
)
return
print(f"【BuffAddStrategy检查】{tick}tick：{char_name}未添加{buff_name}")
================================================
FILE: zsim/sim_progress/Buff/BuffLoad.py
================================================
from __future__ import annotations
from typing import TYPE_CHECKING
import numpy as np
import pandas as pd
from zsim.define import (
BUFF_LOADING_CONDITION_TRANSLATION_DICT,
EXIST_FILE_PATH,
JUDGE_FILE_PATH,
)
from zsim.sim_progress.Character.skill_class import Skill
from .buff_class import Buff
if TYPE_CHECKING:
from zsim.sim_progress.Load import LoadingMission
from zsim.simulator.simulator_class import Simulator
EXIST_FILE = pd.read_csv(EXIST_FILE_PATH, index_col="BuffName")
JUDGE_FILE = pd.read_csv(JUDGE_FILE_PATH, index_col="BuffName")
JUDGE_FILE = JUDGE_FILE.replace({np.nan: None})
EXIST_FILE = EXIST_FILE.replace({np.nan: None})
class BuffInitCache:
def __init__(self):
self.cache = {}
def get(self, key):
return self.cache.get(key)
def add(self, key, value):
self.cache[key] = value
max_cache = 128
while len(self.cache) > max_cache:
self.cache.popitem()
def __getitem__(self, key):
return self.cache[key]
class BuffJudgeCache(BuffInitCache):
def __init__(self):
super().__init__()
def process_buff(
buff_0,
sub_exist_buff_dict,
mission,
time_now,
selected_characters,
LOADING_BUFF_DICT,
exist_buff_dict: dict,
sim_instance: "Simulator",
):
"""
该函数是公用的buff逻辑处理函数，主要是通过BuffJudge来判断Buff是否应该触发。
注意，此处的buff_0是operator的buff_0，哪怕buff是要加给别的角色，这里也是operator的buff_0
"""
all_match, judge_condition_dict, active_condition_dict = BuffInitialize(
buff_0.ft.index, sub_exist_buff_dict
)
all_match = BuffJudge(buff_0, judge_condition_dict, mission)
if not all_match:
return
# if not buff_0.ft.is_debuff:
"""
在20241114的更新中，我删除了debuff分支。因为buff的add_buff_to被拓展成了4字段，所以就没有必要判断是否是debuff了
如果一个buff是debuff，那么它的add_buff_to字段的最后一位肯定是1，比如0001，
这样，它就一定会在buff_go_to函数中导致'enemy'字段进入selected_characters列表，这样一来，enemy会被当成正常角色来执行正常的buff添加和update。
"""
for char in selected_characters:
# if buff_0.ft.simple_judge_logic:
if buff_0.ft.simple_effect_logic:
for sub_mission_start_tick, sub_mission in mission.mission_dict.items():
if time_now - 1 < sub_mission_start_tick <= time_now:
"""
筛选出正在发生的子任务，如果子任务正在发生就直接执行update，把子任务的str传进buff.update()函数
并且触发对应的分支（start、hit、end），完成符合buff属性的时间、层数更新。
"""
buff_new = Buff(
active_condition_dict,
judge_condition_dict,
sim_instance=sim_instance,
)
buff_new.update(
char,
time_now,
mission.mission_node.skill.ticks,
sub_exist_buff_dict,
sub_mission,
)
buff_new.ft.operator = buff_0.ft.operator
buff_new.ft.passively_updating = buff_0.ft.passively_updating
buff_new.ft.beneficiary = buff_0.ft.beneficiary
if buff_new.dy.is_changed:
LOADING_BUFF_DICT[char].append(buff_new)
"""
这里要注意：process_buff函数中传入的buff_0，只会来自于角色，
所以，如果有上个Enemy的debuff，那么角色自身作为触发源头，正常更新以外，
需要向Enemy的buff_0同步广播。否则，record就无法记录enemy身上Buff的正常层数。
"""
if char == "enemy":
enemy_buff_0 = exist_buff_dict["enemy"][buff_0.ft.index]
buff_new.update_to_buff_0(enemy_buff_0)
else:
"""
这个分支主要是为了处理复杂的effect类的buff的
此类buff的更新往往不依赖start、hit、end三大子标签进行，
所以单独进行处理
"""
buff_new = Buff(active_condition_dict, judge_condition_dict, sim_instance=sim_instance)
buff_new.logic.xeffect()
if buff_new.dy.is_changed:
buff_new.ft.operator = buff_0.ft.operator
buff_new.ft.passively_updating = buff_0.ft.passively_updating
buff_new.ft.beneficiary = buff_0.ft.beneficiary
LOADING_BUFF_DICT[char].append(buff_new)
if char == "enemy":
enemy_buff_0 = exist_buff_dict["enemy"][buff_0.ft.index]
buff_new.update_to_buff_0(enemy_buff_0)
def BuffLoadLoop(
time_now: int,
load_mission_dict: dict,
existbuff_dict: dict,
character_name_box: list,
LOADING_BUFF_DICT: dict,
all_name_order_box: dict,
sim_instance: "Simulator",
):
"""
这是buff修改三部曲的第二步,也是最核心的一个步骤，
该函数会向外抛出LOADING_BUFF_DICT——本tick触发了多少BUFF/DEBUFF，并且移交给BuffAdd函数，执行buff的添加。
本函数的核心调用函数是ProcessBuff函数。
"""
# 初始化LOADING_BUFF_DICT
from zsim.sim_progress.Load import LoadingMission
all_name_box = character_name_box + ["enemy"]
for character in all_name_box:
LOADING_BUFF_DICT[character] = []
# 遍历load_mission_dict中的任务
for mission in load_mission_dict.values():
if not isinstance(mission, LoadingMission):
raise TypeError(f"当前{mission}不是LoadingMission类！")
actor_name = mission.mission_character
if actor_name not in existbuff_dict:
raise ValueError("当前角色的Buff源并未创建！")
# 提取当前角色的 Buff 列表
# sub_exist_debuff_dict = existbuff_dict['enemy']
for char_name in character_name_box:
sub_exist_buff_dict = existbuff_dict[char_name]
if char_name == actor_name:
process_on_field_buff(
sub_exist_buff_dict,
mission,
time_now,
LOADING_BUFF_DICT,
all_name_order_box,
existbuff_dict,
sim_instance=sim_instance,
)
else:
process_backend_buff(
sub_exist_buff_dict,
all_name_order_box,
mission,
time_now,
LOADING_BUFF_DICT,
existbuff_dict,
sim_instance=sim_instance,
)
return LOADING_BUFF_DICT
def process_on_field_buff(
sub_exist_buff_dict: dict,
mission: "LoadingMission",
time_now: int,
LOADING_BUFF_DICT: dict,
all_name_order_box: dict,
exist_buff_dict: dict,
sim_instance: "Simulator",
):
"""
处理前台Buff的逻辑模块
注意，这部分的分支，指的是以当前的前台角色为第一视角来给自己或是其他人添加Buff。
由于这个循环的前置参数——character_name是从mission里面拿来的，所以“前台角色”不可能是enemy
这意味enemy的所有buff必须是别人添加给它的，目前enemy没有主动更新buff的逻辑。
"""
for buff_key, buff_0 in sub_exist_buff_dict.items():
if not isinstance(buff_0, Buff):
raise TypeError(f"当前{buff_key}不是Buff类！")
if buff_0.ft.schedule_judge:
# 跳过schedule阶段处理的buff
continue
if buff_0.ft.passively_updating:
# 目前正是前台角色触发前台buff，而passively_updating为True时，
# 意味着“当前buff的触发我说了不算，别人说了算”，那么本函数自然无法处理，要直接跳过。
continue
# 提前计算添加Buff的角色列表
main_char = buff_0.ft.operator
all_name_box = all_name_order_box[main_char]
selected_characters = buff_go_to(buff_0, all_name_box)
process_buff(
buff_0,
sub_exist_buff_dict,
mission,
time_now,
selected_characters,
LOADING_BUFF_DICT,
exist_buff_dict,
sim_instance=sim_instance,
)
def process_backend_buff(
sub_exist_buff_dict: dict,
all_name_order_box: dict,
mission: "LoadingMission",
time_now: int,
LOADING_BUFF_DICT: dict,
exist_buff_dict: dict,
sim_instance: "Simulator",
):
"""
处理后台Buff的逻辑，
尽管当前的动作是别的角色（actor ≠ char_name），但是，两位后台角色身上，依旧存在着可能发生更新的Buff
这些Buff都拥有backend_active标签。但并非所有拥有这一标签的buff都应该执行更新。
比如，后台角色A会给所有人叠层，当前台动作满足该Buff的触发条件时，
应只执行该buff所有者（operator）的buff更新，而不执行受益者（beneficiary）的更新，
这样就可以避免buff的重复更新。
以 静听佳音4件套 为例：套装佩戴者位于后台时，如果前台角色使用了快速支援，
那么，在process_on_field_buff函数中，前台角色的嘉音层数不会被更新；
而在此函数中，该buff属于耀佳音的那个buff_0会触发更新，从而实现全队层数+1
"""
for other_buff_key, other_buff_0 in sub_exist_buff_dict.items():
if not isinstance(other_buff_0, Buff):
raise TypeError(f"当前{other_buff_key}不是Buff类！")
if other_buff_0.ft.schedule_judge:
continue
if not other_buff_0.ft.backend_acitve:
continue
if other_buff_0.ft.passively_updating:
continue
main_char = other_buff_0.ft.operator
name_order_box = all_name_order_box[main_char]
selected_characters_back = buff_go_to(other_buff_0, name_order_box)
process_buff(
other_buff_0,
sub_exist_buff_dict,
mission,
time_now,
selected_characters_back,
LOADING_BUFF_DICT,
exist_buff_dict,
sim_instance=sim_instance,
)
def buff_go_to(buff_0, all_name_box):
"""
运行函数前，总有：
all_name_box = character_name_box + ['enemy']
该函数是用来处理buff该加给什么角色的
比如这个buff的add_buff_to字段的内容是1100（加给自己和下一位），那么新的这个selected_characters就会输出[艾莲，莱卡恩]
如果字段内容是1010（加给自己和上一位），那么新的selected_characters就会输出[艾莲，苍角]
"""
adding_code = str(int(buff_0.ft.add_buff_to)).zfill(4)
selected_characters = [
all_name_box[i] for i in range(len(all_name_box)) if adding_code[i] == "1"
]
return selected_characters
def BuffInitialize(
buff_name: str, existbuff_dict: dict, *, cache=BuffInitCache()
) -> tuple[bool, dict, dict]:
cache_key = (buff_name, tuple(existbuff_dict.items()))
if cache_key in cache.cache:
return cache.get(cache_key)
# 对单个buff进行初始化，抛出一个触发状态参数，两个参数序列。
all_match = False
buff_now = existbuff_dict[buff_name]
if not isinstance(buff_now, Buff):
raise ValueError(f"当前正在检索的Buff：{buff_name}并不是Buff类！")
if buff_name not in JUDGE_FILE.index:
raise ValueError(f"Buff{buff_name}不在JUDGE_FILE中！")
judge_condition_dict = dict(JUDGE_FILE.loc[buff_name])
active_condition_dict = dict(EXIST_FILE.loc[buff_name])
active_condition_dict["BuffName"] = buff_name
# 根据buff名称，直接把判断信息从JUDGE_FILE中提出来并且转化成dict。
results = (all_match, judge_condition_dict, active_condition_dict)
cache.add(cache_key, results)
return results
def BuffJudge(
buff_now: Buff,
judge_condition_dict: dict,
mission: "LoadingMission",
*,
cache=BuffJudgeCache(),
) -> bool:
"""
如果judge_condition_dict的全部内容是None，同时buff还是简单判断逻辑
说明是环境或是战斗系统自带的debuff，则直接返回False，跳过判断。
"""
# 以下为缓存逻辑
simple_logic: bool = buff_now.ft.simple_judge_logic
all_simple = [
buff_now.ft.simple_judge_logic,
buff_now.ft.simple_start_logic,
buff_now.ft.simple_hit_logic,
buff_now.ft.simple_end_logic,
buff_now.ft.simple_effect_logic,
buff_now.ft.simple_exit_logic,
]
if all(all_simple):
cache_key = hash((id(buff_now), tuple(judge_condition_dict.items()), id(mission)))
if cache_key in cache.cache:
return cache[cache_key]
result: bool
def save_cache_and_return(result: bool, *, cache=cache):
"""由于本函数有多个return中断，所以写了个这玩意，把直接return换成return这个函数就行"""
if all(all_simple):
cache.add(cache_key, result)
return result
# ——————缓存逻辑结束————————
if buff_now.ft.alltime:
result = True
return save_cache_and_return(result)
if (
not any(value if value is None else True for value in judge_condition_dict.values())
and buff_now.ft.simple_judge_logic
):
# EXPLAIN：全部数据都是None并且是简单判断逻辑
# 这通常意味着Buff的判断不在Load阶段，而是通过某种方式在其他阶段暴力添加。
# 但是部分alltime的buff也会进入这一分支，所以需要在判断alltime之后再进行全空判断。
result = False
return save_cache_and_return(result)
"""
正常buff的判断逻辑
"""
skill_now = mission.mission_node.skill
if not isinstance(skill_now, Skill.InitSkill):
raise TypeError(f"{skill_now}并非Skill类！")
if simple_logic:
all_match = simple_string_judge(judge_condition_dict, skill_now)
else:
try:
all_match = buff_now.logic.xjudge(
loading_mission=mission, skill_node=mission.mission_node
)
except TypeError:
raise TypeError(f"{buff_now.ft.index}的xjudge方法参数错误！")
result = all_match
return save_cache_and_return(result)
def simple_string_judge(judge_condition_dict: dict, skill_now) -> bool:
all_match = True
"""
先假定all_match是True，一会儿循环过程中一旦有不符合的项，就改成False。
只有全部通过才能继续维持All_match的值。
"""
for condition, judge_condition in BUFF_LOADING_CONDITION_TRANSLATION_DICT.items():
"""
由于SkillNode中的属性名和judge_condition_dict中的键值名不同，
所以需要BUFF_LOADING_CONDITION_TRANSLATION_DICT进行翻译。
"""
csv_judge_condition = judge_condition_dict[condition]
if csv_judge_condition is not None:
"""
如果键值下面是None则直接跳过。
"""
final_condition = process_string(csv_judge_condition)
if getattr(skill_now, judge_condition) not in final_condition:
all_match = False
return all_match
def process_string(source: str) -> list[int | float | str]:
"""
在2024.11.13的更新中，从csv中读取的数据从单个数值变成了字符串，但是数据类型有点复杂。
如果单元格内没有分隔符，那么就会被转化为单元素列表，且会自动转换其中的数字为python数字，
如果有分隔符，则会根据分隔符打散成列表，并且将其中的数字转化成python数字。
由于getattr方法获得的技能属性的数值永远是单个的，所以用 技能属性 in list 的判定逻辑，
这样就可以实现“或”逻辑。
"""
if isinstance(source, str):
if "|" in source:
split_list = source.split("|")
return [eval(item) if item.isdigit() else item for item in split_list]
else:
return [eval(source) if source.isdigit() else source]
else:
return [source]
def process_buff_for_test(buff_0, sub_exist_buff_dict, mission):
"""
本函数截取了process_buff函数的头部，专为Pytest服务，正常程序请勿调用！
"""
all_match, judge_condition_dict, active_condition_dict = BuffInitialize(
buff_0.ft.index, sub_exist_buff_dict
)
all_match = BuffJudge(buff_0, judge_condition_dict, mission)
return all_match
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AliceAdditionalAbilityApBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class AliceAdditionalAbilityApBonusRecord(BRBC):
def __init__(self):
super().__init__()
self.trans_ratio: float = 1.6 # 转化比率
class AliceAdditionalAbilityApBonus(Buff.BuffLogic):
def __init__(self, buff_instance: Buff):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
assert self.buff_0 is not None, "buff_0未初始化"
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["爱丽丝"][self.buff_instance.ft.index]
assert self.buff_0 is not None, "buff_0未初始化"
if self.buff_0.history.record is None:
self.buff_0.history.record = AliceAdditionalAbilityApBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""根据触发时的异常掌控，计算转化的Buff层数"""
self.check_record_module()
self.get_prepared(char_CID=1401, sub_exist_buff_dict=1, enemy=1, dynamic_buff_list=1)
assert self.record is not None, "记录模块未初始化"
assert self.record.enemy is not None, "敌人未初始化"
assert self.record.dynamic_buff_list is not None, "动态Buff列表未初始化"
assert self.record.sub_exist_buff_dict is not None, "子存在Buff字典未初始化"
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
mul_data = MultiplierData(
enemy_obj=self.record.enemy,
dynamic_buff=self.record.dynamic_buff_list,
character_obj=self.record.char,
)
am = Calculator.AnomalyMul.cal_am(mul_data)
if am < 140:
return
count = (am - 140) * self.record.trans_ratio
tick = self.buff_instance.sim_instance.tick
self.buff_instance.simple_start(
timenow=tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict, no_count=1
)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(buff_0=self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AliceCinema6Trigger.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
if TYPE_CHECKING:
pass
class AliceCinema6TriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.additional_attack_skill_tag = "1401_Cinema_6" # 6画额外攻击的技能tag
class AliceCinema6Trigger(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["爱丽丝"][self.buff_instance.ft.index]
assert self.buff_0 is not None, "buff_0不能为空"
if self.buff_0.history.record is None:
self.buff_0.history.record = AliceCinema6TriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""爱丽丝的6画额外攻击逻辑判定函数，只会在决胜状态可用时放行队友技能的命中事件"""
self.check_record_module()
self.get_prepared(char_CID=1401)
assert self.record is not None, "记录模块未正确初始化，请检查函数"
assert self.record.char is not None, "角色未正确初始化，请检查函数"
from zsim.sim_progress.Character.Alice import Alice
if not isinstance(self.record.char, Alice):
raise TypeError("【爱丽丝6画触发器警告】初始化时获取的角色并非爱丽丝，请检查初始化逻辑")
skill_node = kwargs.get("skill_node")
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
assert isinstance(skill_node, SkillNode), "skill_node必须为SkillNode类型"
# 首先过滤掉自己的技能
if skill_node.char_name == self.record.char.NAME:
return False
# 当爱丽丝不处于决胜状态时，不触发
if not self.record.char.victory_state:
# print(self.record.char.victory_state_update_tick, self.record.char.victory_state_attack_counter)
return False
# 过滤掉并非处于命中帧的技能
if not skill_node.is_hit_now(tick=self.buff_instance.sim_instance.tick):
return False
else:
if self.record.check_cd(tick_now=self.buff_instance.sim_instance.tick):
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""爱丽丝6画额外攻击触发器的业务函数，主要负责调用角色方法，添加额外攻击的Preload事件"""
self.check_record_module()
self.get_prepared(char_CID=1401)
assert self.record is not None, "记录模块未正确初始化，请检查函数"
assert self.record.char is not None, "角色未正确初始化，请检查函数"
from zsim.sim_progress.Character.Alice import Alice
if not isinstance(self.record.char, Alice):
raise TypeError("【爱丽丝6画触发器警告】初始化时获取的角色并非爱丽丝，请检查初始化逻辑")
self.record.char.spawn_extra_attack()
self.record.last_active_tick = self.buff_instance.sim_instance.tick
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AlicePolarizedAssaultTrigger.py
================================================
from copy import deepcopy
from define import ALICE_REPORT
from zsim.sim_progress.Preload import SkillNode
from .. import Buff, JudgeTools, check_preparation
class AlicePolarizedAssaultTriggerRecord:
def __init__(self):
self.char = None
self.allowed_skill_tag_list: list[str] = ["1401_SNA_3", "1401_Q"] # 合法的极性强击触发源
self.trigger_origin: "SkillNode | None" = None
class AlicePolarizedAssaultTrigger(Buff.BuffLogic):
"""爱丽丝的极性强击触发器"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.buff_0 = None
self.record: AlicePolarizedAssaultTriggerRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["爱丽丝"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = AlicePolarizedAssaultTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs) -> bool:
"""极性强击的判断函数，放行三蓄和大招"""
self.check_record_module()
self.get_prepared(char_CID=1401)
skill_node = kwargs.get("skill_node")
if skill_node is None:
return False
if not isinstance(skill_node, SkillNode):
return False
if skill_node.skill_tag not in self.record.allowed_skill_tag_list:
return False
tick = self.buff_instance.sim_instance.tick
if not skill_node.is_last_hit(tick=tick):
return False
# 小于2画时，大招无法触发极性强击
if skill_node.skill_tag == "1401_Q" and self.record.char.cinema < 2:
return False
if self.record.trigger_origin is not None:
raise ValueError(
f"【极性强击触发器警告】存在尚未处理的触发源{self.record.trigger_origin.skill_tag}"
)
self.record.trigger_origin = skill_node
# print(f"【测试】当前时间{tick}，{skill_node.skill_tag}即将通过判定。preload_tick: {skill_node.preload_tick}， end_tick: {skill_node.end_tick}，tick_list: {skill_node.tick_list}")
return True
def special_effect_logic(self, **kwargs):
"""极性强击触发器的执行函数，构造一个极性强击事件并且将其添加进event_list中，同时置空自己的触发信号"""
self.check_record_module()
self.get_prepared(char_CID=1401)
from zsim.sim_progress.data_struct import PolarizedAssaultEvent
sim_instance = self.buff_instance.sim_instance
tick = sim_instance.tick
enemy = sim_instance.schedule_data.enemy
copyed_anomaly_bar = deepcopy(enemy.anomaly_bars_dict[0])
copyed_anomaly_bar.activated_by = self.record.trigger_origin
event = PolarizedAssaultEvent(
execute_tick=tick,
anomlay_bar=copyed_anomaly_bar,
char_instance=self.record.char,
skill_node=self.record.trigger_origin,
)
event_list = sim_instance.schedule_data.event_list
event_list.append(event)
if ALICE_REPORT:
sim_instance.schedule_data.change_process_state()
print(
f"【爱丽丝事件】{self.record.trigger_origin.skill.skill_text} 最后一Hit命中，创建了一个极性强击事件！"
)
self.record.trigger_origin = None
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AnomalyDebuffExitJudge.py
================================================
from .. import Buff, JudgeTools
anomaly_statement_dict = {
"Buff-异常-霜寒": "frostbite",
"Buff-异常-畏缩": "assault",
"Buff-异常-烈霜霜寒": "frost_frostbite",
}
class AnomalyDebuffExitJudge(Buff.BuffLogic):
"""
理论上所有属性异常导致的debuff都适用这退出特效。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.last_frostbite = False
self.last_frost_frostbite = False
self.last_assault = False
self.last_shock = False
self.last_burn = False
self.last_corruption = False
self.enemy = None
def special_exit_logic(self, **kwargs):
"""
特殊属性异常退出机制
即：属性异常结束（检测到下降沿）就结束
"""
if self.enemy is None:
self.enemy = JudgeTools.find_enemy(sim_instance=self.buff_instance.sim_instance)
anomaly_name = anomaly_statement_dict[self.buff_instance.ft.index]
anomaly_now = getattr(self.enemy.dynamic, anomaly_name)
anomaly_statement = [
getattr(self.buff_instance.logic, f"last_{anomaly_name}"),
anomaly_now,
]
def mode_func(a, b):
return a is True and b is False
result = JudgeTools.detect_edge(anomaly_statement, mode_func)
setattr(self.buff_instance.logic, f"last_{anomaly_name}", anomaly_now)
return result
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AstraYaoChordManagerTrigger.py
================================================
from zsim.define import ASTRAYAO_REPORT
from .. import Buff, JudgeTools, check_preparation, find_tick
class AstraYaoChordManagerTriggerRecord:
def __init__(self):
self.char = None
self.last_update_node = None
class AstraYaoChordManagerTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""耀嘉音震音管理器触发器，负责调用震音管理器并尝试添加协同攻击。"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["耀嘉音"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = AstraYaoChordManagerTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""放行所有的符合条件的技能"""
self.check_record_module()
self.get_prepared(char_CID=1311)
skill_node = kwargs["skill_node"]
if skill_node.skill.trigger_buff_level in [5, 7, 8]:
if find_tick(sim_instance=self.buff_instance.sim_instance) == skill_node.preload_tick:
self.record.last_update_node = skill_node
return True
return False
def special_start_logic(self, **kwargs):
"""special_start函数只会在动作开始时执行，控制了执行的次数，防止重复触发。"""
self.check_record_module()
self.get_prepared(char_CID=1311)
char = self.record.char
skill_node = self.record.last_update_node
from zsim.sim_progress.Character.AstraYao import AstraYao
if not isinstance(char, AstraYao):
raise TypeError("record.char is not AstraYao")
char.chord_manager.chord_trigger.try_spawn_chord_coattack(
find_tick(sim_instance=self.buff_instance.sim_instance),
skill_node=skill_node,
)
if ASTRAYAO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(f"检测到入场动作{skill_node.skill_tag}，尝试调用震音管理器，触发协同攻击！")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AstraYaoCorePassiveAtkBonus.py
================================================
from zsim.define import ASTRAYAO_REPORT
from .. import Buff, JudgeTools, check_preparation, find_tick
class AstraYaoCorePassiveAtkBonusRecord:
def __init__(self):
self.char = None
self.core_passive_ratio = 0.35
self.duration_added_per_active = 1200
self.update_info_box = {}
self.sub_exist_buff_dict = None
class AstraYaoCorePassiveAtkBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""耀嘉音核心被动攻击力的xstart方法"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0: Buff | None = None
self.record = None
self.xstart = self.special_start_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["耀嘉音"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = AstraYaoCorePassiveAtkBonusRecord()
self.record = self.buff_0.history.record
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1311, sub_exist_buff_dict=1)
from zsim.sim_progress.Character import Character
if not isinstance(self.record.char, Character):
raise TypeError
benifit = kwargs.get("benifit", None)
if benifit is None:
raise ValueError(f"{self.buff_instance.ft.index}的xstart函数并未获取到benifit参数")
static_atk = self.record.char.statement.ATK
count = min(static_atk * self.record.core_passive_ratio, self.buff_instance.ft.maxcount)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if self.buff_0.dy.active and benifit in self.record.update_info_box:
last_update_tick = self.record.update_info_box[benifit]["startticks"]
if last_update_tick == find_tick(sim_instance=self.buff_instance.sim_instance):
# print(f'已经检测到{benifit}角色在当前tick有过buff更新，所以不做重复更新！！！')
return
# last_update_duration = self.record.update_info_box[benifit]["endticks"] - last_update_tick
last_update_end_tick = self.record.update_info_box[benifit]["endticks"]
"""如果本次buff更新的受益者曾在很久之前被加过buff，但是buff早就掉了，那么就当成第一次触发处理。"""
if last_update_end_tick < tick:
last_update_end_tick = tick
self.buff_instance.simple_start(
tick, self.record.sub_exist_buff_dict, no_start=1, no_count=1, no_end=1
)
self.buff_instance.dy.startticks = tick
# self.buff_instance.dy.endticks = min(last_update_duration - tick + last_update_tick + 1200, self.buff_instance.ft.maxduration+tick)
self.buff_instance.dy.endticks = min(
last_update_end_tick + 1200, self.buff_instance.ft.maxduration + tick
)
# if self.buff_instance.dy.startticks > self.buff_instance.dy.endticks:
# print(self.buff_instance.dy.startticks, self.buff_instance.dy.endticks, benifit)
# print(self.record.update_info_box[benifit])
else:
self.buff_instance.simple_start(
tick, self.record.sub_exist_buff_dict, no_count=1, no_end=1
)
self.buff_instance.dy.endticks = tick + self.record.duration_added_per_active
self.buff_instance.dy.count = count
# if self.buff_instance.dy.startticks > self.buff_instance.dy.endticks:
# print(self.buff_instance.dy.startticks, self.buff_instance.dy.endticks, benifit)
self.record.update_info_box[benifit] = {
"startticks": tick,
"endticks": self.buff_instance.dy.endticks,
"count": count,
}
self.buff_instance.update_to_buff_0(self.buff_0)
if ASTRAYAO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"核心被动触发器激活！成功为{benifit}角色添加攻击力buff（{count}点）！Buff的时间节点为：{self.buff_instance.dy.startticks}--{self.buff_instance.dy.endticks}"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AstraYaoIdyllicCadenza.py
================================================
from .. import Buff, JudgeTools, check_preparation
class AstraYaoIdyllicCadenzaRecord:
def __init__(self):
self.char = None
class AstraYaoIdyllicCadenza(Buff.BuffLogic):
def __init__(self, buff_instance):
"""耀嘉音咏叹华彩的加成效果的判定逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["耀嘉音"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = AstraYaoIdyllicCadenzaRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测咏叹华彩状态"""
self.check_record_module()
self.get_prepared(char_CID=1311)
if self.record.char.get_resources()[1]:
return True
else:
return False
def special_exit_logic(self, **kwargs):
return not self.special_judge_logic(**kwargs)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AstraYaoQuickAssistManagerTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class AstraYaoQuickAssistManagerTriggerRecord:
def __init__(self):
self.char = None
class AstraYaoQuickAssistManagerTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""耀嘉音快支管理器的触发器，该触发器只负责把skill_node或者loading_mission扔给特殊资源模块。"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["耀嘉音"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = AstraYaoQuickAssistManagerTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
return True
def special_effect_logic(self, **kwargs):
"""通过简单判定之后，执行special_effect_logic"""
self.check_record_module()
self.get_prepared(char_CID=1311)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return
self.record.char.chord_manager.quick_assist_trigger_manager.update_myself(
find_tick(sim_instance=self.buff_instance.sim_instance), skill_node
)
# if ASTRAYAO_REPORT:
# print(f'检测到攻击动作命中，尝试调用快支管理器！')
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/AstralVoice.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class AstralVoiceRecord:
def __init__(self):
self.equipper = None
self.char = None
self.trigger_buff_0 = None
self.sub_exist_buff_dict = None
self.action_stack = None
class AstralVoice(Buff.BuffLogic):
"""
这是静听佳音四件套的生效逻辑。该Buff有一个“触发器”，
该触发器由简单逻辑控制，会根据支援突击触发、叠层和刷新；
而触发器本身并无效果，真正实现增伤和复杂判定的是本buff的逻辑模块。
本模块由 复杂判定（xjudge） 和 复杂生效（xstart） 两个部分构成
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"静听嘉音", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
"""
这里的初始化，找到的buff_0实际上是佩戴者的buff_0，
即使是在受益者的buff.history.record中存储的，也是装备佩戴者的buff_0。
"""
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = AstralVoiceRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
复杂判定逻辑：首先要检测触发器Buff的激活情况；
即：trigger_buff_0.dy.active
然后是对比trigger_buff_level，对比通过才能输出True
"""
self.check_record_module()
self.get_prepared(
equipper="静听嘉音",
trigger_buff_0=(
self.buff_instance.ft.operator,
"Buff-驱动盘-静听嘉音-嘉音",
),
action_stack=1,
)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
if self.record.trigger_buff_0.dy.active and skill_node.skill.trigger_buff_level == 7:
if skill_node.loading_mission.mission_dict.get(tick_now, None) == "start":
return True
else:
return False
else:
return False
def special_effect_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(
equipper="静听嘉音",
trigger_buff_0=(
self.buff_instance.ft.operator,
"Buff-驱动盘-静听嘉音-嘉音",
),
sub_exist_buff_dict=1,
)
tick_now = find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_instance.dy.count = self.record.trigger_buff_0.dy.count
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/BackendJudge.py
================================================
from .. import Buff, JudgeTools
class BackendJudge(Buff.BuffLogic):
"""
后台判定的通用逻辑模块
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
def special_judge_logic(self, **kwargs):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
self.buff_instance.ft.bufffrom,
sim_instance=self.buff_instance.sim_instance,
)
name_box = JudgeTools.find_init_data(sim_instance=self.buff_instance.sim_instance).name_box
if name_box[0] != self.equipper:
return True
else:
return False
def special_exit_logic(self, **kwargs):
result = self.xjudge()
if result:
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/BasicComplexBuffClass.py
================================================
from .. import Buff, JudgeTools, check_preparation
class BaseBuffRecord:
"""基础记录Class"""
def __init__(self):
self.char = None
self.buff_0 = None
self.exist_buff_dict = None
self.sub_exist_buff_dict = None
self.preload_data = None
self.trigger_buff_0 = None
self.equipper = None
class BasicComplexBuffClass(Buff.BuffLogic):
RECORD_CLASS = BaseBuffRecord
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.xhit = self.special_hit_logic
self.xeffect = self.special_effect_logic
def get_prepared(self, **kwargs):
"""通用准备检查方法"""
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self, **kwargs):
"""通用记录模块检查"""
char_name = kwargs.get("char_name", None)
if char_name is None:
raise ValueError(
f"{self.buff_instance.ft.index}在进行初始化时，复杂Buff逻辑中的check_record_module函数中并未传入有效的char_name参数！"
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[char_name][self.buff_instance.ft.index]
if not hasattr(self.buff_0.history, "record") or self.buff_0.history.record is None:
self.buff_0.history.record = self.RECORD_CLASS()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
pass
def special_exit_logic(self, **kwargs):
pass
def special_start_logic(self, **kwargs):
pass
def special_hit_logic(self, **kwargs):
pass
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/BranchBladeSongCritDamageBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation
class BranchBladeSongRecord:
def __init__(self):
self.equipper = None
self.enemy = None
self.dynamic_buff_list = None
self.char = None
class BranchBladeSongCritDamageBonus(Buff.BuffLogic):
"""
该buff是新冰4件套中的第一特效：异常掌控>=115就会触发。
由于不能实现“异常掌控>=115时候，将buff.ft.alltime修改为True的操作，
所以只能让该buff在每个动作都检测，然后每个动作都触发，用来平替alltime。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"折枝剑歌", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = BranchBladeSongRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="折枝剑歌", enemy=1, dynamic_buff_list=1)
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
am = Calculator.AnomalyMul.cal_am(mul_data)
if am >= 115:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/BranchBladeSongCritRateBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class BranchBladeSongCritRateBonusRecord:
def __init__(self):
self.enemy = None
self.equipper = None
self.main_module = None
self.char = None
self.last_tick_freez_statement = 0, False
class BranchBladeSongCritRateBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
该buff是新冰4的第二特效，需要检测冻结和碎冰效果。
也就是enemy.dynamic.frozen的状态，只要发生改变，就可以触发。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"折枝剑歌", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = BranchBladeSongCritRateBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="折枝剑歌", enemy=1)
tick = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
if self.record.enemy.dynamic.frozen is None:
this_tick_freez_statement = False
else:
this_tick_freez_statement = self.record.enemy.dynamic.frozen
if this_tick_freez_statement != self.record.last_tick_freez_statement[1]:
self.record.last_tick_freez_statement = tick, this_tick_freez_statement
return True
else:
self.record.last_tick_freez_statement = tick, this_tick_freez_statement
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/CannonRotor.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class CannonRotorRecord:
def __init__(self):
self.equipper = None
self.char = None
self.enemy = None
self.dynamic_buff_list = None
self.skill_tag = "CannonRotorAdditionalDamage"
self.preload_data = None
self.sub_exist_buff_dict = None
class CannonRotor(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"加农转子", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = CannonRotorRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="加农转子", enemy=1, dynamic_buff_list=1, sub_exist_buff_dict=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数获取的skill_node不是SkillNode类型！"
)
if skill_node.char_name != self.record.char.NAME:
return False
if not skill_node.is_hit_now(find_tick(sim_instance=self.buff_instance.sim_instance)):
return False
from zsim.sim_progress.RandomNumberGenerator import RNG
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
rng: RNG = self.buff_instance.sim_instance.rng_instance
normalized_value = rng.random_float()
cric_rate = Calculator.RegularMul.cal_crit_rate(mul_data)
if normalized_value <= cric_rate:
return True
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="加农转子", enemy=1, dynamic_buff_list=1, preload_data=1)
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
from zsim.sim_progress.Preload.SkillsQueue import spawn_node
whole_skill_tag = str(self.record.char.CID) + "_" + self.record.skill_tag
node = spawn_node(
whole_skill_tag,
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.preload_data.skills,
)
from zsim.sim_progress.Load import LoadingMission
mission = LoadingMission(node)
mission.mission_start(find_tick(sim_instance=self.buff_instance.sim_instance))
node.loading_mission = mission
event_list.append(node)
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/CinderCobaltAtkBonus.py
================================================
from zsim.sim_progress.Buff import Buff, JudgeTools, check_preparation, find_tick
class CinderCobaltAtkBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.listener = None
class CinderCobaltAtkBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"「灰烬」-钴蓝", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = CinderCobaltAtkBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="「灰烬」-钴蓝")
if self.record.listener is None:
self.record.listener = self.buff_instance.sim_instance.listener_manager.get_listener(
listener_owner=self.record.char,
listener_id=self.buff_instance.ft.listener_id,
)
active_signal = self.record.listener.active_signal
if active_signal is None:
return False
if active_signal[0].NAME != self.record.char.NAME:
return False
else:
self.record.listener.active_signal = None
if self.buff_0.is_ready(find_tick(sim_instance=self.buff_instance.sim_instance)):
# print(
# f"{self.buff_instance.ft.index}接收到了匹配的更新信号（佩戴者为{active_signal[0].NAME}）"
# )
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/CordisGerminaCritRateBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class CordisGerminaCritRateBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
class CordisGerminaCritRateBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record: CordisGerminaCritRateBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"机巧心种", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = CordisGerminaCritRateBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="机巧心种")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/CordisGerminaEleDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as Brbc
class CordisGerminaEleDmgBonusRecord(Brbc):
def __init__(self):
super().__init__()
class CordisGerminaEleDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是机巧心种电属性增伤Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record: CordisGerminaEleDmgBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"机巧心种", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = CordisGerminaEleDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""机巧心种的电属性增伤Buff触发器，由于在后台也需要监听，所以这里需要用脚本进行判断"""
self.check_record_module()
self.get_prepared(equipper="机巧心种")
assert self.record is not None
skill_node = kwargs.get("skill_node", None)
from zsim.sim_progress.Preload import SkillNode
assert isinstance(skill_node, SkillNode)
# 首先筛选掉没有佩戴机巧心种的角色的技能
if skill_node.char_name != self.record.char.NAME:
return False
# 筛选掉不是强化E和普攻的技能。
if skill_node.skill.trigger_buff_level not in [0, 2]:
return False
# 筛选掉非命中帧
tick = self.buff_instance.sim_instance.tick
if not skill_node.is_hit_now(tick=tick):
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/CordisGerminaSNAAndQIgnoreDefense.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as Brbc
class CordisGerminaSNAAndQIgnoreDefenseRecord(Brbc):
def __init__(self):
super().__init__()
class CordisGerminaSNAAndQIgnoreDefense(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是机巧心种普攻大招无视防御Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record: CordisGerminaSNAAndQIgnoreDefenseRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"机巧心种", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = CordisGerminaSNAAndQIgnoreDefenseRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="机巧心种", trigger_buff_0=("equipper", "机巧心种-电属性增伤"))
assert self.record is not None
assert self.record.trigger_buff_0 is not None
result = len(self.record.trigger_buff_0.dy.built_in_buff_box) == 2
return result
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="机巧心种", trigger_buff_0=("equipper", "机巧心种-电属性增伤"))
return not self.xjudge
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/DawnsBloom4SetTriggerNADmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as Brbc
class DawnsBloom4SetTriggerNADmgBonusRecord(Brbc):
def __init__(self):
super().__init__()
class DawnsBloom4SetTriggerNADmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是拂晓生花四件套触发普攻增伤Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record: DawnsBloom4SetTriggerNADmgBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"拂晓生花", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = DawnsBloom4SetTriggerNADmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""拂晓生花4件套触发普攻增伤，仅对强攻角色生效"""
self.check_record_module()
self.get_prepared(equipper="拂晓生花")
assert self.record is not None
# 对于非强攻角色，永远不触发
if self.record.char.specialty != "强攻":
return False
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
assert isinstance(skill_node, SkillNode)
# 筛选掉不是强化E和大招的技能
if skill_node.skill.trigger_buff_level not in [2, 6]:
return False
tick = self.buff_instance.sim_instance.tick
if skill_node.preload_tick != tick:
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/ElectroLipGlossAtkAndDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class ElectroLipGlossAtkAndDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.enemy = None
class ElectroLipGlossAtkAndDmgBonus(Buff.BuffLogic):
"""触电唇彩判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"触电唇彩", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = ElectroLipGlossAtkAndDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到目标处于异常状态就放行。"""
self.check_record_module()
self.get_prepared(equipper="触电唇彩", enemy=1)
if self.record.enemy.dynamic.is_under_anomaly():
return True
else:
return False
def special_exit_logic(self, **kwargs):
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/ElegantVanityDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class ElegantVanityDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.last_update_tick_node = None
class ElegantVanityDmgBonus(Buff.BuffLogic):
"""玲珑妆匣的全队增伤Buff逻辑。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"玲珑妆匣", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = ElegantVanityDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
判断传入的skill_node的能耗是否>=25，如果是则放行
"""
self.check_record_module()
self.get_prepared(equipper="玲珑妆匣")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
raise ValueError(f"{self.buff_instance.ft.index}的Xjudge函数获取到的skill_node为None！")
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的Xjudge函数获取到的skill_node类型错误！"
)
# 过滤不是自己的skill_node
if skill_node.char_name != self.record.char.NAME:
return False
if skill_node.preload_tick < JudgeTools.find_tick(
sim_instance=self.buff_instance.sim_instance
):
return False
if skill_node.skill.sp_consume >= 25:
if self.record.last_update_tick_node is None:
self.record.last_update_tick_node = skill_node
# print(f'增伤Buff因{skill_node.skill_tag}触发！')
return True
else:
if self.record.last_update_tick_node.UUID != skill_node.UUID:
self.record.last_update_tick_node = skill_node
# print(f'增伤Buff因{skill_node.skill_tag}触发！')
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/ElegantVanitySpRecover.py
================================================
from .. import Buff, JudgeTools, check_preparation
class ElegantVanitySpRecoverRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.energy_value_dict = {1: 5, 2: 5.5, 3: 6, 4: 6.5, 5: 7}
class ElegantVanitySpRecover(Buff.BuffLogic):
"""玲珑妆匣的回能Buff逻辑。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"玲珑妆匣", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = ElegantVanitySpRecoverRecord()
self.record = self.buff_0.history.record
def special_start_logic(self, **kwargs):
"""
这部分的代码主要是负责构建一个ScheduleRefreshData实例的，
而simple_start只是为了启动一次，让Log记录到这个buff。
Buff自身没有效果。
"""
self.check_record_module()
self.get_prepared(equipper="玲珑妆匣", sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
energy_value = self.record.energy_value_dict[int(self.buff_instance.ft.refinement)]
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
from zsim.sim_progress.data_struct import ScheduleRefreshData
refresh_data = ScheduleRefreshData(
sp_target=(self.record.char.NAME,),
sp_value=energy_value,
)
event_list.append(refresh_data)
# print(f'玲珑妆匣回能触发！')
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/FlamemakerShakerApBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class FlamemakerShakerApBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.trigger_buff_0 = None
class FlamemakerShakerApBonus(Buff.BuffLogic):
"""灼心摇壶的精通增幅判定"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"灼心摇壶", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = FlamemakerShakerApBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到目标buff层数>=5时候放行"""
self.check_record_module()
self.get_prepared(equipper="灼心摇壶", trigger_buff_0=("equipper", "灼心摇壶-增伤"))
if not self.record.trigger_buff_0.dy.active:
return False
if self.record.trigger_buff_0.dy.count < 5:
return False
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/FlamemakerShakerDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class FlamemakerShakerDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.preload_data = None
self.sub_exist_buff_dict = None
class FlamemakerShakerDmgBonus(Buff.BuffLogic):
"""灼心摇壶的增伤逻辑判定"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"灼心摇壶", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = FlamemakerShakerDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到强化E标签或是支援攻击标签，则放行。如果角色处于前台则更新1层，若角色处于后台则更新两层。"""
self.check_record_module()
self.get_prepared(equipper="灼心摇壶")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
# 滤去不是自己的技能
if self.record is not None and self.record.equipper != skill_node.char_name:
return False
if skill_node.skill.trigger_buff_level == 2:
return True
else:
if skill_node.skill.labels is not None:
# 若技能有标签，则判断是否是支援攻击标签。
if "Assist_Attack" in skill_node.skill.labels:
return True
else:
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="灼心摇壶", preload_data=1, sub_exist_buff_dict=1)
if self.record.preload_data.operating_now != self.record.char.CID:
# 说明此时角色正位于后台，更新两层。
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
no_count=1,
)
self.buff_instance.dy.count = min(
self.buff_instance.dy.count + 2, self.buff_instance.ft.maxcount
)
else:
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
self.buff_instance.update_to_buff_0(self.buff_0)
# print(f'灼心摇壶更新了{update_count}层，当前层数为：{self.buff_0.dy.count}')
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/FlightOfFancy.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class FlightOfFancyRecord:
def __init__(self):
self.equipper = None
self.char = None
class FlightOfFancy(Buff.BuffLogic):
"""飞鸟星梦的复杂逻辑，监测到装备者造成以太伤害时叠层。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"飞鸟星梦", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = FlightOfFancyRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到装备者的以太伤害技能，并且处于Hit节点。"""
self.check_record_module()
self.get_prepared(equipper="飞鸟星梦")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
# 滤去不是自己的技能
if self.record.equipper != skill_node.char_name:
return False
# 滤去非以太伤害的技能
if skill_node.element_type != 4:
return False
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if skill_node.loading_mission.is_hit_now(tick):
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/FreedomBlues.py
================================================
from .. import Buff, JudgeTools, check_preparation
class FreedomBluesRecord:
def __init__(self):
self.equipper = None
self.char = None
self.action_stack = None
class FreedomBlues(Buff.BuffLogic):
"""
这是自由蓝调的复杂判定逻辑。
自由蓝调被分为6个buff，但是共用这一个逻辑模块。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"自由蓝调", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = FreedomBluesRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
只有装备者位于前台，并且当前的动作是强化E才会进入下一轮判断
只有当强化E 属性与buff自身的refinement想同，才会输出True。
这里，refinement被借用来记录buff对应的属性种类。
"""
self.check_record_module()
self.get_prepared(equipper="自由蓝调", action_stack=1)
action_now = self.record.action_stack.peek()
element_type_trigger = self.buff_instance.ft.refinement
if (
str(self.record.char.CID) in action_now.mission_tag
and action_now.mission_node.skill.trigger_buff_level == 2
):
if action_now.mission_node.element_type == element_type_trigger:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HailstormShrineIceBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
anomaly_name_list = ["frostbite", "assault", "shock", "burn", "corruption"]
class HailstormShrineIceBonusRecord:
def __init__(self):
self.anomaly_state = {name: False for name in anomaly_name_list}
self.equipper = None
self.action_stack = None
self.enemy = None
self.char = None
class HailstormShrineIceBonus(Buff.BuffLogic):
"""
该buff为雅专武的冰伤判定模块。
它需要检测所有的属性异常，找它们的上升沿。
或者是当前动作的trigger_buff_level为强化特殊技
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"霰落星殿", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HailstormShrineIceBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="霰落星殿", enemy=1, action_stack=1)
action_now = self.record.action_stack.peek()
current_anomalies = {
name: getattr(self.record.enemy.dynamic, name) for name in anomaly_name_list
}
# 判断总异常数量是否 >= 2
if sum(current_anomalies.values()) >= 2 or sum(self.record.anomaly_state.values()) >= 2:
raise ValueError("当前ticks总异常数量为2！")
# 检查是否有状态变化或满足特殊技触发条件
has_change = any(
current_anomalies[name] != self.record.anomaly_state[name] for name in anomaly_name_list
)
if has_change or (
action_now.mission_node.skill.trigger_buff_level == 2
and str(self.record.char.CID) in action_now.mission_tag
):
self.record.anomaly_state.update(current_anomalies)
return True
# 更新状态并返回
self.record.anomaly_state.update(current_anomalies)
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HeartstringNocturne.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class HeartstringNocturneRecord:
def __init__(self):
self.equipper = None
self.char = None
self.listener_exist = False
self.listener = None
class HeartstringNocturne(Buff.BuffLogic):
"""心弦夜响的复杂逻辑：进入战斗或是释放连携技、大招时触发。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"心弦夜响", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HeartstringNocturneRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="心弦夜响")
if not self.record.listener_exist:
self.record.listener = self.buff_instance.sim_instance.listener_manager.get_listener(
listener_owner=self.record.char,
listener_id="Heartstring_Nocturne_1",
)
# self.record.listener = self.buff_instance.sim_instance.listener_manager.listener_factory(
# initiate_signal="Heartstring_Nocturne_1", sim_instance=self.buff_instance.sim_instance
# )
self.record.listener_exist = True
# print(f"为{self.record.char.NAME}创建了一个心弦夜响的监听器！")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数获取的skill_node不是SkillNode类型！"
)
active_signal = self.record.listener.active_signal
if active_signal is not None:
event_obj: SkillNode = active_signal[0]
if event_obj.char_name == self.record.char.NAME:
return True
else:
if skill_node.char_name == self.record.char.NAME:
if skill_node.preload_tick == find_tick(
sim_instance=self.buff_instance.sim_instance
) and skill_node.skill.trigger_buff_level in [5, 6]:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HellfireGearsSpRBonus.py
================================================
from .. import Buff, JudgeTools
class HellfireGearsSpRBonus(Buff.BuffLogic):
"""
燃狱齿轮的后台回能。需要在初始化的时候就获取角色和武器配置列表
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
def special_judge_logic(self, **kwargs):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"燃狱齿轮", sim_instance=self.buff_instance.sim_instance
)
name_box = JudgeTools.find_init_data(sim_instance=self.buff_instance.sim_instance).name_box
if name_box[0] != self.equipper:
return True
else:
return False
def special_exit_logic(self, **kwargs):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"燃狱齿轮", sim_instance=self.buff_instance.sim_instance
)
name_box = JudgeTools.find_init_data(sim_instance=self.buff_instance.sim_instance).name_box
if name_box[0] == self.equipper:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HormonePunkAtkBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class HormonePunkAtkBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.listener_exist = False
self.listener = None
class HormonePunkAtkBonus(Buff.BuffLogic):
"""激素朋克的复杂逻辑模块，检测到监听器更新信号时更新。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"激素朋克", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HormonePunkAtkBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到更新信号时，返回True，并且置空监听器的active_signal。"""
self.check_record_module()
self.get_prepared(equipper="激素朋克")
if not self.record.listener_exist:
self.record.listener = self.buff_instance.sim_instance.listener_manager.get_listener(
listener_owner=self.record.char, listener_id="Hormone_Punk_1"
)
self.record.listener_exist = True
# print(f"为{self.record.char.NAME}创建了一个激素朋克的监听器！")
active_signal = self.record.listener.active_signal
if active_signal is None:
return False
if active_signal[0].NAME != self.record.char.NAME:
return False
else:
self.record.listener.active_signal = None
if self.buff_0.is_ready(find_tick(sim_instance=self.buff_instance.sim_instance)):
# print(
# f"{self.buff_instance.ft.index}接收到了匹配的更新信号（佩戴者为{active_signal[0].NAME}），buff更新时间{self.buff_0.dy.startticks}， buff结束时间为{self.buff_0.dy.endticks}"
# )
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HugoAdditionalAbilityExtraQTEDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class HugoAdditionalAbilityExtraQTEDmgBonusRecord:
def __init__(self):
self.char = None
self.enemy = None
class HugoAdditionalAbilityExtraQTEDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""雨果组队被动，连携技对普通敌人增伤"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0: Buff | None = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雨果"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HugoAdditionalAbilityExtraQTEDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""连携技对普通敌人增伤"""
self.check_record_module()
self.get_prepared(char_CID=1291, enemy=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取到的skill_node不是SkillNode类型"
)
"""过滤不是自己的技能"""
if "1291" not in skill_node.skill_tag:
return False
"""过滤不是连携技的技能"""
if skill_node.skill.trigger_buff_level != 5:
return False
"""普通敌人的筛选是通过可连携次数来判断的"""
if self.record.enemy.QTE_triggerable_times <= 1:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HugoCorePassiveDoubleStunAtkBonus.py
================================================
from zsim.define import HUGO_REPORT
from .. import Buff, JudgeTools, check_preparation
class HugoCorePassiveDoubleStunAtkBonusRecord:
def __init__(self):
self.char = None
self.stun_char_count = None
self.char_obj_list = None
class HugoCorePassiveDoubleStunAtkBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""雨果核心被动，双击破角色的攻击力加成"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0: Buff | None = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雨果"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HugoCorePassiveDoubleStunAtkBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""当队伍里存在2名被击角色时，触发该效果"""
self.check_record_module()
self.get_prepared(char_CID=1291, char_obj_list=1)
if self.record.stun_char_count is None:
self.record.stun_char_count = 0
for char_obj in self.record.char_obj_list:
from zsim.sim_progress.Character import Character
if not isinstance(char_obj, Character):
raise TypeError("char_obj_list中的对象不是Character类的实例")
if char_obj.specialty == "击破":
self.record.stun_char_count += 1
if HUGO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"雨果的双击破角色攻击力Buff在初始化阶段检测到了队伍中有{self.record.stun_char_count}名击破角色"
)
stun_char_count = self.record.stun_char_count
if stun_char_count >= 2:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HugoCorePassiveEXStunBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class HugoCorePassiveEXStunBonusRecord:
def __init__(self):
self.char = None
self.enemy = None
class HugoCorePassiveEXStunBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""雨果核心被动，E对非失衡状态的敌人造成的失衡值提升"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0: Buff | None = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雨果"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HugoCorePassiveEXStunBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""强化E命中非失衡状态的敌人时触发"""
self.check_record_module()
self.get_prepared(char_CID=1291, enemy=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取到的skill_node不是SkillNode类型"
)
"""过滤不是自己的技能"""
if "1291" not in skill_node.skill_tag:
return False
"""过滤不是强化E的技能"""
if skill_node.skill.trigger_buff_level != 2:
return False
if self.record.enemy.dynamic.stun:
return False
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HugoCorePassiveSingleStunAtkBonus.py
================================================
from zsim.define import HUGO_REPORT
from zsim.sim_progress.Buff import Buff, JudgeTools, check_preparation
class HugoCorePassiveSingleStunAtkBonusRecord:
def __init__(self):
self.char = None
self.stun_char_count = None
self.char_obj_list = None
class HugoCorePassiveSingleStunAtkBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""雨果核心被动，单击破角色的攻击力加成"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0: Buff | None = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雨果"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HugoCorePassiveSingleStunAtkBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""当队伍里存在一名被击角色时，触发该效果"""
self.check_record_module()
self.get_prepared(char_CID=1291, char_obj_list=1)
if self.record.stun_char_count is None:
self.record.stun_char_count = 0
for char_obj in self.record.char_obj_list:
from zsim.sim_progress.Character import Character
if not isinstance(char_obj, Character):
raise TypeError("char_obj_list中的对象不是Character类的实例")
if char_obj.specialty == "击破":
self.record.stun_char_count += 1
if HUGO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"雨果的单击破角色攻击力Buff在初始化阶段检测到了队伍中有{self.record.stun_char_count}名击破角色"
)
stun_char_count = self.record.stun_char_count
if stun_char_count >= 1:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/HugoCorePassiveTotalizeTrigger.py
================================================
from zsim.define import HUGO_REPORT
from zsim.sim_progress.Enemy import Enemy
from .. import Buff, JudgeTools, check_preparation, find_tick
class HugoCorePassiveTotalizeTriggerRecord:
def __init__(self):
self.char = None
self.enemy: Enemy | None = None
self.active_signal = None
self.E_totalize_tag = "1291_CorePassive_E_EX"
self.Q_totalize_tag = "1291_CorePassive_Q"
self.totalize_buff_index = "Buff-角色-雨果-决算倍率增幅"
self.abyss_reverb_buff_index = "Buff-角色-雨果-核心被动-暗渊回响"
self.cinema_1_buff_index = "Buff-角色-雨果-1画-决算招式双暴增幅"
self.cinema_2_buff_index = "Buff-角色-雨果-2画-决算招式无视防御力"
self.cinema_6_buff_index = "Buff-角色-雨果-6画-决算招式增伤"
self.preload_data = None
self.shot_attack_list = [
"1291_SNA_2_NFC",
"1291_SNA_2_FC",
"1291_SCA",
"1291_SCA_FC",
"1291_NA_A",
"1291_NA_A_FC",
"1291_BH_Aid_A",
"1291_BH_Aid_A_FC",
]
# self.fc_shot_attack_list = [
# "1291_SNA_2_FC",
# "1291_SCA_FC",
# "1291_NA_A_FC",
# "1291_BH_Aid_A_FC",
# ]
class HugoCorePassiveTotalizeTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""雨果核心被动，决算触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0: Buff | None = None
self.record: HugoCorePassiveTotalizeTriggerRecord | None = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雨果"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = HugoCorePassiveTotalizeTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""敌人处于失衡状态时，强化E、大招触发"""
self.check_record_module()
self.get_prepared(char_CID=1291, enemy=1, preload_data=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取到的skill_node不是SkillNode类型"
)
# 过滤不是自己的技能
if "1291" not in skill_node.skill_tag:
return False
# 过滤不是E、大招的技能
if skill_node.skill.trigger_buff_level not in [2, 6]:
"""6画时，任何射击攻击都可以借由本触发器来执行暗渊回响Buff的触发"""
if (
self.record.char.cinema == 6
and skill_node.skill_tag in self.record.shot_attack_list
):
if skill_node.loading_mission is None:
raise ValueError(f"{skill_node.skill_tag}本应该有loading_mission，但是没有")
if not skill_node.loading_mission.is_last_hit(
find_tick(sim_instance=self.buff_instance.sim_instance)
):
return False
else:
self.record.active_signal = skill_node.skill.trigger_buff_level
return True
else:
return False
# 过滤掉无法触发决算的第一段强化E
if skill_node.skill_tag == "1291_E_EX_1":
return False
# 过滤掉可能进入Buff循环的决算？？大概率不可能吧，决算能进BuffLoad那真的是见鬼了
if skill_node.skill.labels is not None:
if "totalize" in skill_node.skill.labels:
return False
# 过滤不是最后一次命中的技能
if skill_node.loading_mission is None:
return False
if not skill_node.loading_mission.is_last_hit(
find_tick(sim_instance=self.buff_instance.sim_instance)
):
return False
if self.record.active_signal is not None:
raise ValueError(
f"雨果的决算触发器在运行时候发现存在就一个未被结算的信号{self.record.active_signal}，这是不允许的"
)
# 如果是6命，则无条件放行强化E
if self.record.char.cinema == 6 and skill_node.skill.trigger_buff_level == 2:
self.record.active_signal = skill_node.skill.trigger_buff_level
return True
else:
# 否则，检测敌人是否处于失衡状态
if self.record.enemy.dynamic.stun:
self.record.active_signal = skill_node.skill.trigger_buff_level
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""结算E、大招"""
self.check_record_module()
self.get_prepared(char_CID=1291, enemy=1, preload_data=1)
if self.record.active_signal is None:
raise ValueError("雨果的决算触发器的Xjudge函数放行了，但是Xhit函数却没有获取到触发信号")
if self.record.active_signal not in [0, 2, 6]:
raise ValueError(
f"雨果的决算触发器的Xjudge函数放行了，但是给出了非法信号！触发信号：{self.record.active_signal}"
)
elif self.record.active_signal == 0 and self.record.char.cinema != 6:
raise ValueError(f"在非6画的情况下检测到了非法的触发信号：{self.record.active_signal}")
"""准备数据"""
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
rest_tick = self.record.enemy.get_stun_rest_tick()
ratio = 1000 + min(300, rest_tick) / 60 * 280 + min(600, max(rest_tick - 300, 0)) / 60 * 100
if self.record.active_signal in [2, 6]:
if HUGO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"雨果使用{'大招' if self.record.active_signal == 6 else '强化E'}触发了决算！本次决算结算的失衡时间为{rest_tick / 60:.2f}秒，结算倍率为{ratio:.2f}%，"
)
else:
if HUGO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print("6画触发：检测到射击攻击命中！为雨果触发一次暗渊回响Buff！")
"""先处理Buff"""
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
if self.record.active_signal == 0:
abyss_reverb_buff_index = self.record.abyss_reverb_buff_index
buff_add_strategy(
abyss_reverb_buff_index,
benifit_list=["雨果"],
sim_instance=self.buff_instance.sim_instance,
)
self.record.active_signal = None
"""触发信号为0时，只添加Buff，不执行后面的逻辑。"""
return
else:
buff_index = self.record.totalize_buff_index
buff_add_strategy(
buff_index,
specified_count=ratio,
benifit_list=["雨果"],
sim_instance=self.buff_instance.sim_instance,
)
stun_value_feed_back_ratio = min(rest_tick / 60, 5) * 0.05
if self.record.char.cinema >= 1:
cinema_1_buff_index = self.record.cinema_1_buff_index
buff_add_strategy(
cinema_1_buff_index,
benifit_list=["雨果"],
sim_instance=self.buff_instance.sim_instance,
)
if self.record.char.cinema >= 2:
cinema_2_buff_index = self.record.cinema_2_buff_index
buff_add_strategy(
cinema_2_buff_index,
benifit_list=["雨果"],
sim_instance=self.buff_instance.sim_instance,
)
if self.record.char.cinema == 6:
cinema_6_buff_index = self.record.cinema_6_buff_index
buff_add_strategy(
cinema_6_buff_index,
benifit_list=["雨果"],
sim_instance=self.buff_instance.sim_instance,
)
"""再生成决算的skill_node"""
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload.SkillsQueue import spawn_node
if self.record.active_signal == 2:
node_tag = self.record.E_totalize_tag
elif self.record.active_signal == 6:
node_tag = self.record.Q_totalize_tag
else:
raise ValueError("雨果的决算触发器的Xjudge函数放行了，但是给出的信号不是强化E、大招")
totalize_node = spawn_node(
node_tag,
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.preload_data.skills,
)
"""给予技能节点一个loading_mission"""
totalize_node.loading_mission = LoadingMission(totalize_node)
totalize_node.loading_mission.mission_start(
find_tick(sim_instance=self.buff_instance.sim_instance)
)
event_list.append(totalize_node)
"""失衡状态强制结算事件"""
from zsim.sim_progress.data_struct import StunForcedTerminationEvent
if self.record.enemy.dynamic.stun:
if self.record.char.cinema >= 2 and self.record.active_signal == 6:
if HUGO_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print("2画触发：检测到雨果释放大招，根据2画效果，本次决算不终结失衡状态！")
stun_event = None
else:
stun_event = StunForcedTerminationEvent(
self.record.enemy,
stun_value_feed_back_ratio,
execute_tick=find_tick(sim_instance=self.buff_instance.sim_instance),
event_source="雨果",
)
else:
if self.record.char.cinema != 6:
raise ValueError(
"雨果的决算触发器的Xjudge函数放行了，但是敌人并未处于失衡状态，这对于非6画雨果来说是不允许的。"
)
elif self.record.active_signal != 2:
raise ValueError(
f"触发信号为{self.record.active_signal}，这意味着6画雨果的大招在非失衡期触发了决算，这是不允许的"
)
else:
stun_event = None
"""2画以上的大招触发决算时，不结算失衡状态。"""
if stun_event is not None:
event_list.append(stun_event)
"""重置信号"""
self.record.active_signal = None
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/IceJadeTeaPotExtraDMGBonus.py
================================================
from .. import Buff, JudgeTools
class IceJadeTeaPotExtraDMGBonus(Buff.BuffLogic):
"""
青衣专武>=15层时的额外增伤触发判定。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
def special_judge_logic(self, **kwargs):
equipper = JudgeTools.find_equipper(
"玉壶青冰", sim_instance=self.buff_instance.sim_instance
)
dynamic_buff_list = JudgeTools.find_dynamic_buff_list(
sim_instance=self.buff_instance.sim_instance
)
for buffs in dynamic_buff_list[equipper]:
if "玉壶青冰-普攻加冲击" not in buffs.ft.index:
continue
if buffs.dy.count >= 15:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JaneAdditionalAbilityPhyBuildupBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class JaneAdditionalAbilityPhyBuildupBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
class JaneAdditionalAbilityPhyBuildupBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""简组队被动中第二特效的复杂逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JaneAdditionalAbilityPhyBuildupBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""简组队被动的第二特效是：只要有敌人处于异常状态即可触发，所以只要有任意一种异常处于激活状态，就可以放行。"""
self.check_record_module()
self.get_prepared(char_CID=1261, enemy=1)
return self.record.enemy.dynamic.is_under_anomaly()
def special_exit_logic(self, **kwargs):
"""此Buff退出逻辑和触发逻辑相反"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JaneCinema1APTransToDmgBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation, find_tick
class JaneCinema1APTransToDmgBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
class JaneCinema1APTransToDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""1画的狂热状态下的精通转模增伤buff的复杂逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JaneCinema1APTransToDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""简的1画精通转增伤部分，触发逻辑和狂热触发器挂钩；"""
self.check_record_module()
self.get_prepared(char_CID=1261, trigger_buff_0=("简", "Buff-角色-简-狂热状态触发器"))
if self.record.trigger_buff_0.dy.active:
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""当触发器激活时，执行self.xhit，计算实时精通，转化为增伤层数。"""
self.check_record_module()
self.get_prepared(
char_CID=1261,
trigger_buff_0=("简", "Buff-角色-简-狂热状态触发器"),
dynamic_buff_list=1,
enemy=1,
sub_exist_buff_dict=1,
)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
ap = Cal.AnomalyMul.cal_ap(mul_data)
count = min(ap * 0.1, self.buff_instance.ft.maxcount)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick, self.record.sub_exist_buff_dict, no_count=1)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
def special_exit_logic(self, **kwargs):
"""精通转增伤Buff的退出逻辑与触发器相反"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JaneCoreSkillStrikeCritDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class JaneCoreSkillStrikeCritDmgBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
class JaneCoreSkillStrikeCritDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""简核心被动中，强击暴击伤害的复杂逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JaneCoreSkillStrikeCritDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""强击的暴伤Debuff情况是和啮咬绑定的。"""
self.check_record_module()
self.get_prepared(
char_CID=1261, trigger_buff_0=("enemy", "Buff-角色-简-核心被动-啮咬触发器")
)
if self.record.trigger_buff_0.dy.active:
return True
else:
return False
def special_exit_logic(self, **kwargs):
"""此Buff退出逻辑和触发逻辑相反"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JaneCoreSkillStrikeCritRateBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation, find_tick
class JaneCoreSkillStrikeCritRateBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
class JaneCoreSkillStrikeCritRateBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""简核心被动中，强击暴击率的复杂逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JaneCoreSkillStrikeCritRateBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""强击暴击率的Debuff情况是和啮咬绑定的。"""
self.check_record_module()
self.get_prepared(
char_CID=1261, trigger_buff_0=("enemy", "Buff-角色-简-核心被动-啮咬触发器")
)
if self.record.trigger_buff_0.dy.active:
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""当触发器激活时，执行self.xhit，计算实时精通，转化成暴击率层数。"""
self.check_record_module()
self.get_prepared(
char_CID=1261,
trigger_buff_0=("enemy", "Buff-角色-简-核心被动-啮咬触发器"),
dynamic_buff_list=1,
enemy=1,
sub_exist_buff_dict=1,
)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
ap = Cal.AnomalyMul.cal_ap(mul_data)
count = min(40 + ap * 0.16, 100)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick, self.record.sub_exist_buff_dict, no_count=1)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
def special_exit_logic(self, **kwargs):
"""此Buff退出逻辑和触发逻辑相反"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JanePassionStateAPTransToATK.py
================================================
from math import floor
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation, find_tick
class JanePassionStateAPTransToATKRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
class JanePassionStateAPTransToATK(Buff.BuffLogic):
def __init__(self, buff_instance):
"""狂热状态下的精通转攻击力"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JanePassionStateAPTransToATKRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""精通转攻击力部分的触发行为与触发器对齐；"""
self.check_record_module()
self.get_prepared(char_CID=1261, trigger_buff_0=("简", "Buff-角色-简-狂热状态触发器"))
if self.record.trigger_buff_0.dy.active:
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""当触发器激活时，执行self.xhit，计算实时精通，激活自身状态并且更新层数。"""
self.check_record_module()
self.get_prepared(
char_CID=1261,
trigger_buff_0=("简", "Buff-角色-简-狂热状态触发器"),
dynamic_buff_list=1,
enemy=1,
sub_exist_buff_dict=1,
)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
ap = Cal.AnomalyMul.cal_ap(mul_data)
count = floor(
max(ap - 120, 0)
) # 超过120点的部分，每1点叠1层，这里应该是向下取证，比如120.1，那就不叠层。
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick, self.record.sub_exist_buff_dict, no_count=1)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
def special_exit_logic(self, **kwargs):
"""精通转攻击力Buff的退出逻辑与触发器相反"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JanePassionStatePhyBuildupBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class JanePassionStatePhyBuildupBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
class JanePassionStatePhyBuildupBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""狂热状态下的积蓄效率的判定逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JanePassionStatePhyBuildupBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""积蓄效率Buff的判定和触发器有关，其状态和触发器相同"""
self.check_record_module()
self.get_prepared(char_CID=1261, trigger_buff_0=("简", "Buff-角色-简-狂热状态触发器"))
if self.record.trigger_buff_0.dy.active:
return True
else:
return False
def special_exit_logic(self, **kwargs):
"""积蓄效率的退出逻辑与触发器相反"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/JanePassionStateTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation
class JanePassionStateTriggerRecord:
def __init__(self):
self.char = None
class JanePassionStateTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""简单的狂热状态触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["简"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = JanePassionStateTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""简的狂热状态触发器，其取值狂热状态同步"""
self.check_record_module()
self.get_prepared(char_CID=1261)
passion_state = self.record.char.get_special_stats().get("狂热状态")
if passion_state is None:
raise ValueError(f"{self.buff_instance.ft.index} 的xjudge模块并未获取到简的狂热状态！")
if passion_state:
return True
else:
return False
def special_exit_logic(self, **kwargs):
"""简的狂热状态触发器的退出逻辑，和触发函数持相反逻辑"""
return not self.special_judge_logic()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/KaboomTheCannon.py
================================================
from .. import Buff, JudgeTools, check_preparation
class KaboomTheCannonRecord:
def __init__(self):
self.equipper = None
self.char = None
self.action_stack = None
self.active_char_dict = {}
self.sub_exist_buff_dict = None
class KaboomTheCannon(Buff.BuffLogic):
"""
好斗的阿炮的复杂逻辑模块。主要是“1人只能提供1层”这个部分的约束
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xhit = self.special_hit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"好斗的阿炮", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
"""
这里的初始化，找到的buff_0实际上是佩戴者的buff_0
"""
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = KaboomTheCannonRecord()
self.record = self.buff_0.history.record
def special_hit_logic(self, **kwargs):
"""主要归档触发源。"""
# TODO: 等三只小猪加入了，可能还得重新弄。
self.check_record_module()
self.get_prepared(equipper="好斗的阿炮", action_stack=1, sub_exist_buff_dict=1)
action_now = self.record.action_stack.peek()
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.record.active_char_dict[action_now.mission_character] = [
tick_now,
tick_now + self.buff_instance.ft.maxduration,
]
for names, tick_list in self.record.active_char_dict.copy().items():
if tick_list[1] <= tick_now:
del self.record.active_char_dict[names]
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict, not_count=True)
input_list = list(self.record.active_char_dict.values())
self.buff_instance.dy.built_in_buff_box = input_list
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LighterAdditionalAbility_IceFireBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation
class LighterExtraSkillRecord:
def __init__(self):
self.char = None
self.enemy = None
self.dynamic_buff_list = None
self.sub_exist_buff_dict = None
self.real_count = 0
class LighterExtraSkill_IceFireBonus(Buff.BuffLogic):
"""
这个buff的特性是：能叠20层，每层起码有1.25%冰火增伤。但是，每次层数更新时，都会检测冲击力，
冲击力超过170的部分，都会以0.025%的数值增幅到这个1.25%的基础数值上。
模型转换：
以0.25%为一层，本buff最多300层。
buff本身层数分为两种，一种为虚层（fake_count），另一种为实层（real_count）。
实层根据命中次数，每次5层（共1.25%）稳定增加，每次实层更新后（self.update_to_buff0，该函数无法调用，需要手动)
那么有效叠加次数：hit_count = real_count / 5，而且这个一定是int。
根据当前冲击力超过170的部分，算出每个effect_count所享受的虚层增幅fake_count_delta : （当前冲击力-170）/10，该数值可以是个小数
实层传回buff_0的专用字段 buff.history.real_count 保存，下一次再拿。
本tick的实际生效层数，也就是最后记录到self.dy.count 的算法是：
self.dy.count = min(real_count + hit_count * fake_count_delta, 300)
下一个ticks，虚层清空，重新计算，实层重新从buff_0拿过来\
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["莱特"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LighterExtraSkillRecord()
self.record = self.buff_0.history.record
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1161, enemy=1, dynamic_buff_list=1, sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
buff_i = self.buff_instance
buff_i.simple_start(tick_now, self.record.sub_exist_buff_dict)
# 由于buff.dy.count的最终修改逻辑是直接赋值，不涉及累加。所以这里还原simple_start的步骤应该是多余的。
# buff_i.dy.count -= buff_i.ft.step
"""
先处理real_count的逻辑，最多100层（叠加20次）
只要该模块执行了，那就说明又命中了一次，自然要+5层。
但是这里用作计算的层数，不能来自simple_start之后的buff.dy.count，
而应该是来自于record.real_count。
这一步实现了命中叠加最基本层数，并且实时更新到realcount中。
"""
real_count = min(self.record.real_count + buff_i.ft.step, 100)
self.record.real_count = real_count
# 计算实时冲击力
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
stun_value = Calculator.StunMul.cal_imp(mul_data)
# 计算虚层
fake_count_delta = max((stun_value - 170) / 10, 0)
sum_fake_count = real_count / 5 * fake_count_delta
# 计算等效的实际生效层数
buff_i.dy.count = min(real_count + sum_fake_count, 300)
buff_i.update_to_buff_0(self.buff_0)
# print('buff_i：', main_module.tick, buff_i.dy.active, buff_i.dy.startticks, buff_i.dy.endticks, real_count, sum_fake_count)
# print('buff_0：', buff_0.dy.active, buff_0.dy.startticks, buff_0.dy.endticks, buff_0.history.real_count)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LighterUniqueSkillStunBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class LighterUniqueSkillStunBonusRecord:
def __init__(self):
self.last_morale = 0
self.last_morale_delta = 0
self.buff_count = 0
self.sub_exist_buff_dict = None
self.char = None
class LighterUniqueSkillStunBonus(Buff.BuffLogic):
"""
该buff是复杂判断 + 复杂生效双代码控制。
检测莱特士气的变化。如果发生了变化，则返回True
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["莱特"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LighterUniqueSkillStunBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
调用这个方法的位置，应该是buff_0的xjudge，所以，有效的self.buff_count也是存在buff_0里面的。
"""
self.check_record_module()
self.get_prepared(char_CID=1161)
if self.record.last_morale > self.record.char.morale:
# 检测到士气的下降之后，计算士气差，并且转化为层数预存起来。
self.record.last_morale_delta = (
self.record.last_morale - self.record.char.morale
) / 100
self.record.buff_count = self.record.last_morale_delta
self.record.last_morale = self.record.char.morale
# 暂时假设不向下取整。
return True
else:
self.record.last_morale = self.record.char.morale
return False
def special_effect_logic(self):
"""
这个方法需要在xjudge通过之后调用，此时调用的是buff_new的xeffect。
所以这里需要向buff_0获取它的的层数。
"""
self.check_record_module()
self.get_prepared(char_CID=1161, sub_exist_buff_dict=1)
buff_i = self.buff_instance
tick = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
buff_i.simple_start(tick, self.record.sub_exist_buff_dict)
buff_i.dy.count -= buff_i.ft.step
buff_i.dy.count = min(buff_i.dy.count + self.record.buff_count, buff_i.ft.maxcount)
buff_i.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LighterUniqueSkillStunTimeLimitBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class LighterUniqueSkillStunTimeRecord:
def __init__(self):
self.last_stun_statement = False
self.enemy = None
class LighterUniqueSkillStunTimeLimitBonus(Buff.BuffLogic):
"""
该buff的退出逻辑特殊，失衡结束就会直接退出。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["莱特"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LighterUniqueSkillStunTimeRecord()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
"""
获取当前失衡值，和上一次失衡值对比。
"""
self.check_record_module()
self.get_prepared(enemy=1)
if self.record.last_stun_statement and not self.record.enemy.dynamic.stun:
self.record.last_stun_statement = self.record.enemy.dynamic.stun
return True
else:
self.record.last_stun_statement = self.record.enemy.dynamic.stun
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LinaAdditionalSkillEleDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class LinaAdditionalSkillRecord:
def __init__(self):
self.enemy = None
class LinaAdditionalSkillEleDMGBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
丽娜组队被动：感电增加全队电伤
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["丽娜"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LinaAdditionalSkillRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(enemy=1)
if self.record.enemy.dynamic.shock:
return True
else:
return False
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(enemy=1)
if not self.record.enemy.dynamic.shock:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LinaCoreSkillPenRatioBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation
class LinaCoreSkillRecord:
def __init__(self):
self.action_stack = None
self.char = None
self.enemy = None
self.dynamic_buff_list = None
self.sub_exist_buff_dict = None
class LinaCoreSkillPenRatioBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
丽娜核心被动，穿透率增幅。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["丽娜"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LinaCoreSkillRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
只要不是重击，就都触发。
"""
self.check_record_module()
self.get_prepared(action_stack=1)
if self.record.action_stack.peek().mission_tag == "1211_SNA_1":
return False
else:
return True
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(
action_stack=1,
char_CID=1211,
dynamic_buff_list=1,
enemy=1,
sub_exist_buff_dict=1,
)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_0.dy.count -= self.buff_0.ft.step
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
pen_ratio = Cal.RegularMul.cal_pen_ratio(mul_data)
count = min(pen_ratio * 0.2 * 100 + 12, self.buff_instance.ft.maxcount)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
def special_exit_logic(self, **kwargs):
"""
只要检测到重击，就立刻终止。
"""
self.check_record_module()
self.get_prepared(action_stack=1)
if self.record.action_stack.peek().mission_tag != "1211_SNA_1":
tick = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
if self.buff_instance.dy.endticks <= tick:
return True
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LunarNoviluna.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class LunarNovilunaRecord:
def __init__(self):
self.equipper = None
self.char = None
self.enegy_value_map = {1: 3, 2: 3.5, 3: 4, 4: 4.5, 5: 5}
self.sub_exist_buff_dict = None
class LunarNoviluna(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"「月相」-朔", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LunarNovilunaRecord()
self.record = self.buff_0.history.record
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="「月相」-朔", sub_exist_buff_dict=1)
from zsim.sim_progress.data_struct import ScheduleRefreshData
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
energy_value = self.record.enegy_value_map[self.buff_instance.ft.refinement]
refresh_data = ScheduleRefreshData(
sp_target=(self.record.char.NAME,),
sp_value=energy_value,
)
event_list.append(refresh_data)
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/LyconAdditionalAbilityStunVulnerability.py
================================================
from .. import Buff, JudgeTools, check_preparation
class LyconAdditionalAbility:
def __init__(self):
self.last_stun_statement = False
self.action_stack = None
self.enemy = None
self.info_dict = None
class LyconAdditionalAbilityStunVulnerability(Buff.BuffLogic):
"""
该buff的退出逻辑特殊，失衡结束就会直接退出。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["莱卡恩"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = LyconAdditionalAbility()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
"""
该buff和莱特的核心被动失衡时间延长是一样的，都是要在失衡期消失的时候检测退出。
获取当前失衡值，和上一次失衡值对比。
"""
self.check_record_module()
self.get_prepared(enemy=1)
if self.record.last_stun_statement and not self.record.enemy.dynamic.stun:
self.record.last_stun_statement = self.record.enemy.dynamic.stun
return True
else:
self.record.last_stun_statement = self.record.enemy.dynamic.stun
return False
def special_judge_logic(self, **kwargs):
"""
进入机制。获取当前skillNode并且检测当前怪物的失衡状态，两者都符合才触发。
"""
self.check_record_module()
self.get_prepared(enemy=1, action_stack=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
if "1141" in skill_node.skill_tag and self.record.enemy.dynamic.stun:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MagneticStormAlphaAMBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class MagneticStormAlphaAMBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
class MagneticStormAlphaAMBonus(Buff.BuffLogic):
"""电磁暴1式判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"「电磁暴」-壹式", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MagneticStormAlphaAMBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只要造成了积蓄值，就放行"""
self.check_record_module()
self.get_prepared(equipper="「电磁暴」-壹式")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
# 滤去不是自己的技能
if self.record.equipper != skill_node.char_name:
return False
if (
skill_node.skill.anomaly_accumulation != 0
and skill_node.skill.element_damage_percent > 0
):
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MagneticStormBravoApBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class MagneticStormBravoApBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
class MagneticStormBravoApBonus(Buff.BuffLogic):
"""电磁暴2式判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"「电磁暴」-贰式", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MagneticStormBravoApBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只要造成了积蓄值，就放行"""
self.check_record_module()
self.get_prepared(equipper="「电磁暴」-贰式")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
# 滤去不是自己的技能
if self.record.equipper != skill_node.char_name:
return False
if (
skill_node.skill.anomaly_accumulation != 0
and skill_node.skill.element_damage_percent > 0
):
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MagneticStormCharlieSpRecover.py
================================================
from .. import Buff, JudgeTools, check_preparation
class MagneticStormCharlieSpRecoverRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.energy_value_dict = {1: 3.5, 2: 4, 3: 4.5, 4: 5, 5: 5.5}
class MagneticStormCharlieSpRecover(Buff.BuffLogic):
"""电磁暴3式判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"「电磁暴」-叁式", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MagneticStormCharlieSpRecoverRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只要造成了积蓄值，就放行"""
self.check_record_module()
self.get_prepared(equipper="「电磁暴」-叁式")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
# 滤去不是自己的技能
if self.record.equipper != skill_node.char_name:
return False
if (
skill_node.skill.anomaly_accumulation != 0
and skill_node.skill.element_damage_percent > 0
):
return True
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="「电磁暴」-叁式", sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
energy_value = self.record.energy_value_dict[int(self.buff_instance.ft.refinement)]
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
from zsim.sim_progress.data_struct import ScheduleRefreshData
refresh_data = ScheduleRefreshData(
sp_target=(self.record.char.NAME,),
sp_value=energy_value,
)
event_list.append(refresh_data)
print("电磁暴3式回能触发！")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MarcatoDesireAtkBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class MarcatoDesireRecord:
def __init__(self):
self.equipper = None
self.char = None
self.enemy = None
class MarcatoDesireAtkBonus(Buff.BuffLogic):
"""强音热望的复杂逻辑：连携技或强化E命中属性异常状态下敌人时触发"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"强音热望", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MarcatoDesireRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="强音热望", enemy=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数获取的skill_node不是SkillNode类型！"
)
if skill_node.char_name != self.record.char.NAME:
return False
if not skill_node.is_hit_now(find_tick(sim_instance=self.buff_instance.sim_instance)):
return False
if skill_node.skill.trigger_buff_level in [2, 5]:
if self.record.enemy.dynamic.is_under_anomaly():
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MetanukiMorphosisAPBonus.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class MetanukiMorphosisAPBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
class MetanukiMorphosisAPBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record: MetanukiMorphosisAPBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"狸法七变化", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MetanukiMorphosisAPBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到装备者的追加攻击时放行，但是需要注意此效果只能生效一个"""
self.check_record_module()
self.get_prepared(equipper="狸法七变化")
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.char_name != self.record.char.NAME:
return False
if not skill_node.have_label(label_key="aftershock_attack"):
return False
if skill_node.is_hit_now(tick=self.buff_instance.sim_instance.tick):
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MiyabiAdditionalAbility_IgnoreIceRes.py
================================================
from .. import Buff, JudgeTools, check_preparation
anomaly_name_list = ["frostbite", "assault", "shock", "burn", "corruption"]
class MiyabiAdditionalAbility:
def __init__(self):
self.anomaly_state = {name: False for name in anomaly_name_list}
self.disorder = False
self.effect_count = 0
self.action_stack = None
self.enemy = None
class MiyabiAdditionalAbility_IgnoreIceRes(Buff.BuffLogic):
"""
该buff为雅的组队被动中，紊乱后蓄力重击无视冰抗，
该Buff需要检测紊乱，这一判定必须对比：当前tick下enemy的状态 和 本buff逻辑模块内记录的上一次判定过程中的enemy状态，
重点在于，必须保证当前tick和上一次记录的tick只相差1，这样才不会误判紊乱的发生。
主要需要规避的情况：
1、第n个ticks检测到霜寒，
2、n+1ticks 时，角色被切到后台了，
3、第n+x个ticks的时候，角色重新回到前台，并且检测到灼烧，
那么这里就会自然而然判定为“disorder”，这是误判。
由于紊乱的产生只有1个tick，要准确检测到紊乱，必须每个tick实时获取enemy的状态，
所以，该buff必须每个tick都被执行一次判定逻辑，
我修改了buff的backend_active参数，这样，雅在前台时，它能通过Load的主逻辑进行判断
而角色在后台时，也可以通过Load的副逻辑，passively_updating == True且backend_active == True的分支，来执行判断。
检测到紊乱发生后，buff的生效次数 effect_count 自增1，最多1层，
只有当effect_count 的层数是1，且当前的动作（action_stack.peek()获取）
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雅"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MiyabiAdditionalAbility()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(enemy=1, action_stack=1)
action_now = self.record.action_stack.peek()
enemy = self.record.enemy
current_anomalies = {name: getattr(enemy.dynamic, name) for name in anomaly_name_list}
# 获取当前状态
current_count = sum(current_anomalies.values())
last_count = sum(self.record.anomaly_state.values())
# 计算两个list中的True的数量
if last_count >= 2 or current_count >= 2:
raise ValueError("当前ticks总异常数量为2！")
self.record.disorder = (
current_count == 1
and last_count == 1
and any(
current_anomalies[name] != self.record.anomaly_state[name]
for name in anomaly_name_list
)
)
# 当前后的True的数量都是1（意味着上一个Ticks有异常，这个Ticks也有异常），判断二者是否是同一个异常。如果不是，就修改Disorder为True
self.record.anomaly_state.update(current_anomalies)
if self.record.disorder:
self.record.effect_count = min(self.record.effect_count + 1, 1)
if self.record.effect_count > 0 and action_now.mission_tag in [
"1091_SNA_1",
"1091_SNA_2",
"1091_SNA_3",
]:
self.record.effect_count = 0
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MiyabiCoreSkill_FrostBurn.py
================================================
from .. import Buff, JudgeTools, check_preparation
class MiyabiCoreSkillFB:
def __init__(self):
self.last_frostbite = False
self.enemy = None
class MiyabiCoreSkill_FrostBurn(Buff.BuffLogic):
"""
该buff是雅的核心被动中的【霜灼】，【霜灼】的进入机制是，随着烈霜属性异常触发，同步触发。
执行这一步的是：update_anomaly函数，该函数会在烈霜属性积蓄条满的时候，
根据bar.accompany_debuff中记录的str，去添加同名debuff。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雅"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MiyabiCoreSkillFB()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
"""
霜灼buff的退出机制是检测到霜寒的下降沿就退出
"""
self.check_record_module()
self.get_prepared(enemy=1)
frostbite_now = self.record.enemy.dynamic.frost_frostbite
frostbite_statement = [self.record.last_frostbite, frostbite_now]
def mode_func(a, b):
return a is True and b is False
result = JudgeTools.detect_edge(frostbite_statement, mode_func)
self.record.last_frostbite = frostbite_now
return result
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MiyabiCoreSkill_IceFire.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress import Preload
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class MiyabiCoreSkillIF:
def __init__(self):
self.char = None
self.sub_exist_buff_dict = None
self.dynamic_buff_list = None
self.last_frostbite = False
self.enemy = None
self.action_stack = None
class MiyabiCoreSkill_IceFire(Buff.BuffLogic):
"""
该buff是雅的核心被动中的【冰焰】，冰焰在判断TrigerBuffLevel的同时，
还需要检索当前enemy_debuff_list中是否含有【霜灼】，如果有就返回False
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["雅"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MiyabiCoreSkillIF()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
这个复杂判断逻辑需要同时检索当前技能的element_type，
以及enemy的debuff_list有没有霜灼，
两者都通过，才会return True
"""
self.check_record_module()
self.get_prepared(char_CID=1091, enemy=1, action_stack=1)
enemy = self.record.enemy
debuff_list = enemy.dynamic.dynamic_debuff_list
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.char_name != self.record.char.NAME:
return False
if skill_node.skill.element_type != 5:
return False
else:
for debuff in debuff_list:
if not isinstance(debuff, Buff):
raise TypeError(f"{debuff}不是Buff类！")
if debuff.ft.index == "Buff-角色-雅-核心被动-霜灼":
return False
else:
return True
def special_exit_logic(self, **kwargs):
"""
冰焰buff的退出机制是检测到霜寒的上升沿就退出
"""
self.check_record_module()
self.get_prepared(char_CID=1091, enemy=1)
enemy = self.record.enemy
frostbite_now = enemy.dynamic.frost_frostbite
if frostbite_now is None:
frostbite_now = False
frostbite_statement = [self.record.last_frostbite, frostbite_now]
def mode_func(a, b):
return a is False and b is True
result = JudgeTools.detect_edge(frostbite_statement, mode_func)
self.record.last_frostbite = frostbite_now
# print(f'当前tick，冰焰退出情况：{result}')
if result:
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
skill_obj = self.record.char.skills_dict["1091_Core_Passive"]
skill_node = Preload.SkillNode(skill_obj, 0)
event_list.append(skill_node)
self.record.char.special_resources(skill_node)
return result
def special_hit_logic(self, **kwargs):
"""
冰焰的生效机制是：根据当前的暴击率，得出当前的Buff层数。
这个效果本应该是随动的，不需要buff判定通过才改变层数，
但是如果buff判定不通过，那么烈霜伤害，该buff层数的变动就没有实际意义，
"""
self.check_record_module()
self.get_prepared(char_CID=1091, enemy=1, dynamic_buff_list=1, sub_exist_buff_dict=1)
enemy = self.record.enemy
dynamic_buff = self.record.dynamic_buff_list
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
buff_i = self.buff_instance
buff_i.simple_start(tick_now, self.record.sub_exist_buff_dict)
buff_i.dy.count -= buff_i.ft.step
mul_data = MultiplierData(enemy, dynamic_buff, self.record.char)
crit_rate = Calculator.RegularMul.cal_crit_rate(mul_data)
count = min(crit_rate, 0.8) * 100
# print(crit_rate, count)
buff_i.dy.count = min(count, self.buff_0.ft.maxcount)
buff_i.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/MoonlightLullabyAllTeamDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class MoonlightLullabyAllTeamDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
class MoonlightLullabyAllTeamDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是月光骑士颂全队增伤Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record: MoonlightLullabyAllTeamDmgBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"月光骑士颂", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = MoonlightLullabyAllTeamDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="月光骑士颂")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/NikoleCoreSkillDefReduction.py
================================================
from .. import Buff, JudgeTools, check_preparation
class NicoleCoreSkillRecord:
def __init__(self):
self.action_stack = None
self.char = None
self.enemy = None
self.dynamic_buff_list = None
self.sub_exist_buff_dict = None
class NicoleCoreSkillDefReduction(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
妮可的核心被动，减防。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["妮可"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = NicoleCoreSkillRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
目前这个buff的触发条件是简化过的。本来应该是检测“强化子弹”
"""
self.check_record_module()
self.get_prepared(action_stack=1)
if self.record.action_stack.peek().mission_tag == "1211_SNA_1":
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/PhaethonsMelody.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class PhaethonsMelodyRecord:
def __init__(self):
self.equipper = None
self.char = None
class PhaethonsMelody(Buff.BuffLogic):
"""法厄同之歌的复杂逻辑，以太增伤部分。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"法厄同之歌", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = PhaethonsMelodyRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""法厄同之歌的复杂逻辑，监测到非装备者的强化E发动时放行。"""
self.check_record_module()
self.get_prepared(equipper="法厄同之歌")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取的skill_node不是SkillNode类！"
)
# 滤去自己的技能
if self.record.equipper == skill_node.char_name:
return False
# 过滤非强化E的技能
if skill_node.skill.trigger_buff_level != 2:
return False
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if skill_node.preload_tick == tick:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/PolarMetalFreezeBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class PolarMetalRecord:
def __init__(self):
self.last_tick_freez_statement = 0, False
self.equipper = None
self.enemy = None
self.char = None
class PolarMetalFreezeBonus(Buff.BuffLogic):
"""
这是极地重金属的复杂逻辑判定。
主要检测的是碎冰的变化状态，如果碎冰状态变了，就返回True
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"极地重金属", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = PolarMetalRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(enemy=1)
enemy = self.record.enemy
tick = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
if enemy.dynamic.frozen is None:
output = False
else:
output = enemy.dynamic.frozen
this_tick_freez_statement = output
if this_tick_freez_statement != self.record.last_tick_freez_statement[1]:
self.record.last_tick_freez_statement = tick, this_tick_freez_statement
return True
else:
self.record.last_tick_freez_statement = tick, this_tick_freez_statement
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/PreciousFossilizedCoreStunBonusOver50Hp.py
================================================
from .. import Buff, JudgeTools
class PreciousFossilizedCoreStunBonusOver50Hp(Buff.BuffLogic):
"""
这段代码是贵重骨核的复杂判断逻辑。
敌人生命大于50%时生效。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
def special_judge_logic(self, **kwargs):
enemy = JudgeTools.find_enemy(sim_instance=self.buff_instance.sim_instance)
hp_pct = enemy.get_total_hp_percentage()
if hp_pct >= 0.5:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/PreciousFossilizedCoreStunBonusOver75Hp.py
================================================
from .. import Buff, JudgeTools
class PreciousFossilizedCoreStunBonusOver75Hp(Buff.BuffLogic):
"""
这段代码是贵重骨核的复杂判断逻辑，
敌人生命值大于等于75%时返回True
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
def special_judge_logic(self, **kwargs):
enemy = JudgeTools.find_enemy(sim_instance=self.buff_instance.sim_instance)
hp_pct = enemy.get_total_hp_percentage()
if hp_pct >= 0.75:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/PuzzleSphereExDmgBonus.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class PuzzleSphereExDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.enemy = None
class PuzzleSphereExDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"幻变魔方", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = PuzzleSphereExDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""幻变魔方的特殊判定逻辑，强化E发动时，若敌人的血量高于50%，则放行。"""
self.check_record_module()
self.get_prepared(equipper="幻变魔方", enemy=1)
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
if skill_node is None:
return False
if skill_node.char_name != self.record.char.NAME:
return False
if skill_node.skill.trigger_buff_level != 2:
return False
if self.record.enemy.get_current_hp_percentage() < 0.5:
return False
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/QingYiAdditionalAbilityStunConvertToATK.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation
class QingYiAdditionalSkillRecord:
def __init__(self):
self.char = None
self.enemy = None
self.sub_exist_buff_dict = None
self.dynamic_buff_list = None
class QingYiAdditionalAbilityStunConvertToATK(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
青衣的组队被动之冲击力转模部分。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["青衣"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = QingYiAdditionalSkillRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
return True
def special_hit_logic(self, **kwargs):
"""
找冲击力，并且构建mul现场算。算完出层数即可。
"""
self.check_record_module()
self.get_prepared(char_CID=1251, enemy=1, dynamic_buff_list=1, sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_0.dy.count -= self.buff_0.ft.step
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
stun_value = Calculator.StunMul.cal_imp(mul_data)
count = min((stun_value - 120) * 6, self.buff_instance.ft.maxcount)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/QingYiCoreSkillExtraStunBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class QintYiCoreSkillExtraStunRecord:
"""
记录信息的类。从青衣开始，这些类要统一管理。
"""
def __init__(self):
self.last_update_voltage = 0
self.sub_exist_buff_dict = None
self.action_stack = None
self.count = 0
self.char = None
class QingYiCoreSkillExtraStunBonus(Buff.BuffLogic):
"""
青衣的核心被动：消耗电压时，
溢出的电压，每1%都会转化为一层额外的失衡值提升作为补偿；
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["青衣"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = QintYiCoreSkillExtraStunRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
检测到SNA_1就为True，否则为False。
这个模块优先于Buff的Start逻辑，所以可以前置更新电压。
并且将计算出的触发情况，放到record里面预存起来。
SNA_1分支，会直接return True，不更新电压，但是直接计算层数。
SNA_2分支，会return True，因为也能吃到这个补偿Buff，且更新电压为0
其他分支，更新电压后，直接返回False
"""
self.check_record_module()
self.get_prepared(char_CID=1251, action_stack=1)
if self.record.action_stack.peek().mission_tag == "1251_SNA_1":
# 这个count哪怕每次SNA_1都计算也不要紧，因为SNA_1分支不会清空电压记录，
# 所以每次算出来都是一样的。
self.record.count = max(self.record.last_update_voltage - 75, 0)
return True
elif self.record.action_stack.peek().mission_tag == "1251_SNA_2":
self.record.last_update_voltage = 0
return True
else:
self.record.last_update_voltage = self.record.char.get_resources()[1]
return False
def special_start_logic(self, **kwargs):
"""
这里是启动逻辑。进入这一逻辑说明是SNA_1或者SNA_2的start标签。
此时，应该从record获取层数，并且激活buff。
"""
self.check_record_module()
self.get_prepared(char_CID=1251, sub_exist_buff_dict=1, action_stack=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_0.dy.count -= self.buff_0.ft.step
count = min(self.record.count, self.buff_instance.ft.maxcount)
self.buff_instance.dy.count = count - 1
self.buff_instance.update_to_buff_0(self.buff_0)
if self.record.action_stack.peek().mission_tag == "1251_SNA_2":
# 在增幅完SNA_2后，本轮次的record.count使命完成，进行重置。
self.record.count = 0
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/QingYiCoreSkillStunDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class QintYiCoreSkillRecord:
"""
记录信息的类。从青衣开始，这些类要统一管理。
"""
def __init__(self):
self.pre_saved_counts = 0
self.last_update_stun = False
self.last_update_skill_tag = None
self.char = None
self.enemy = None
self.sub_exist_buff_dict = None
class QingYiCoreSkillStunDMGBonus(Buff.BuffLogic):
"""
青衣的核心被动：[羁服]——失衡易伤以及连携技增伤；
该buff有两个模块，分别是：XHit以及Xexit
Xhit根据当前的Tag来控制层数的变化；
而Xexit则在检测到失衡状态的下降沿时执行，输出True
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xstart = self.special_start_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["青衣"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = QintYiCoreSkillRecord()
self.record = self.buff_0.history.record
def special_start_logic(self, **kwargs):
"""
检测到当前的action_stack，判断它们的mission_tag
SNA_1叠1层， 且预叠1层；
SNA_2叠5层，且追加叠加所有的预叠层数。
"""
self.check_record_module()
self.get_prepared(char_CID=1251, sub_exist_buff_dict=1, enemy=1)
action_stack = JudgeTools.find_stack(sim_instance=self.buff_instance.sim_instance)
action_now = action_stack.peek()
last_action = action_stack.peek_bottom()
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_0.dy.count -= 1
self.buff_instance.dy.count = self.buff_0.dy.count
if action_now.mission_tag == "1251_SNA_1":
if last_action.mission_tag != "1251_SNA_1":
"""上一个动作不是1251_SNA_1时，强制清空现有层数。"""
self.record.pre_saved_counts = 0
self.buff_instance.dy.count += 1
self.record.pre_saved_counts += 1
if self.record.pre_saved_counts > 5:
raise ValueError(
f"1251_SNA_1提供的预叠层数已经超过了5，\n"
f"当前为：{self.record.pre_saved_counts}，\n"
f"应该是APL代码的逻辑有问题，请检查1251_SNA_2的释放逻辑！"
)
elif action_now.mission_tag == "1251_SNA_2":
self.buff_instance.dy.count += 5
self.buff_instance.dy.count += self.record.pre_saved_counts
self.record.pre_saved_counts = 0
self.buff_instance.dy.count = min(self.buff_instance.dy.count, 20)
self.buff_instance.update_to_buff_0(self.buff_0)
def special_exit_logic(self, **kwargs):
"""
退出逻辑：检测到失衡的下降沿。
"""
self.check_record_module()
self.get_prepared(char_CID=1251, sub_exist_buff_dict=1, enemy=1)
def mode_func(a, b):
return a is True and b is False
stun_statement_tuple = (
self.record.last_update_stun,
self.record.enemy.dynamic.stun,
)
if JudgeTools.detect_edge(stun_statement_tuple, mode_func):
self.record.last_update_stun = self.record.enemy.dynamic.stun
return True
self.record.last_update_stun = self.record.enemy.dynamic.stun
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/QingmingBirdcageCompanionEthDmgBonus.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Character import Character
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
from zsim.simulator.simulator_class import Simulator
class QingmingBirdcageCompanionEthDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.preload_data = None
self.update_signal = None
class QingmingBirdcageCompanionEthDmgBonus(Buff.BuffLogic):
"""青溟笼舍的清明同行的复杂判定，这把武器拥有 以太增伤 以及 贯穿伤害两部分效果，这两部分效果共享同一个判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"青溟笼舍", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = QingmingBirdcageCompanionEthDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""这里有两种放行条件。第一种是装备者的强化E，第二种是刚刚进场时放行。"""
self.check_record_module()
self.get_prepared(equipper="青溟笼舍", preload_data=1)
preload_data: "PreloadData" = self.record.preload_data
char: "Character" = self.record.char
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
sim: "Simulator" = self.buff_instance.sim_instance
if skill_node is None:
return False
# 检测到第一个动作时放行
if skill_node.preload_tick != sim.tick:
return False
if skill_node.char_name != char.NAME:
return False
if len(preload_data.personal_node_stack[char.CID]) == 1:
if self.record.update_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数检验到有尚未处理的更新信号{self.record.update_signal}，本次更新请求来自于{skill_node.skill_tag}请检查XStart函数"
)
self.record.update_signal = 0
return True
else:
if skill_node.skill.trigger_buff_level == 2:
if self.record.update_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数检验到有尚未处理的更新信号{self.record.update_signal}，本次更新请求来自于{skill_node.skill_tag}请检查XStart函数"
)
self.record.update_signal = 1
return True
return False
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="青溟笼舍", sub_exist_buff_dict=1)
sim: "Simulator" = self.buff_instance.sim_instance
if self.record.update_signal is None:
raise ValueError(
f"{self.buff_instance.ft.index}的XStart函数并未检测到有效的更新信号，请检查Xjudge函数！"
)
if self.record.update_signal == 0:
self.buff_instance.simple_start(
timenow=sim.tick,
sub_exist_buff_dict=self.record.sub_exist_buff_dict,
no_count=1,
)
self.buff_instance.dy.count = 2
self.buff_instance.update_to_buff_0(self.buff_0)
self.record.update_signal = None
elif self.record.update_signal == 1:
self.buff_instance.simple_start(
timenow=sim.tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict
)
self.record.update_signal = None
else:
raise ValueError(f"无法解析的更新信号：{self.record.update_signal}")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/QingmingBirdcageCompanionSheerAtkBonus.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Character import Character
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
from zsim.simulator.simulator_class import Simulator
class QingmingBirdcageCompanionSheerAtkBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.preload_data = None
self.update_signal = None
class QingmingBirdcageCompanionSheerAtkBonus(Buff.BuffLogic):
"""青溟笼舍的清明同行的复杂判定，这把武器拥有 以太增伤 以及 贯穿伤害两部分效果，这两部分效果共享同一个判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"青溟笼舍", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = QingmingBirdcageCompanionSheerAtkBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""这里有两种放行条件。第一种是装备者的强化E，第二种是刚刚进场时放行。"""
self.check_record_module()
self.get_prepared(equipper="青溟笼舍", preload_data=1)
preload_data: "PreloadData" = self.record.preload_data
char: "Character" = self.record.char
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
sim: "Simulator" = self.buff_instance.sim_instance
if skill_node is None:
return False
# 检测到第一个动作时放行
if skill_node.char_name != char.NAME:
return False
if skill_node.preload_tick != sim.tick:
return False
if len(preload_data.personal_node_stack[char.CID]) == 1:
if self.record.update_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数检验到有尚未处理的更新信号，请检查XStart函数"
)
self.record.update_signal = 0
return True
if skill_node.skill.trigger_buff_level == 2:
if self.record.update_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数检验到有尚未处理的更新信号，请检查XStart函数"
)
self.record.update_signal = 1
return True
return False
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="青溟笼舍", sub_exist_buff_dict=1)
sim: "Simulator" = self.buff_instance.sim_instance
if self.record.update_signal is None:
raise ValueError(
f"{self.buff_instance.ft.index}的XStart函数并未检测到有效的更新信号，请检查Xjudge函数！"
)
if self.record.update_signal == 0:
self.buff_instance.simple_start(
timenow=sim.tick,
sub_exist_buff_dict=self.record.sub_exist_buff_dict,
no_count=1,
)
self.buff_instance.dy.count = 2
self.buff_instance.update_to_buff_0(self.buff_0)
self.record.update_signal = None
elif self.record.update_signal == 1:
self.buff_instance.simple_start(
timenow=sim.tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict
)
self.record.update_signal = None
else:
raise ValueError(f"无法解析的更新信号：{self.record.update_signal}")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/RainforestGourmetATKBonus.py
================================================
import math
from zsim.sim_progress.Buff import Buff, JudgeTools, check_preparation, find_tick
class RainforestGourmetATKBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.last_update_node = None
class RainforestGourmetATKBonus(Buff.BuffLogic):
"""雨林饕客的局内攻击"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"雨林饕客", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = RainforestGourmetATKBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到强化E标签或是支援攻击标签，则放行。如果角色处于前台则更新1层，若角色处于后台则更新两层。"""
self.check_record_module()
self.get_prepared(equipper="雨林饕客")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError
if skill_node.char_name != self.record.char.NAME:
return False
if skill_node.preload_tick != find_tick(sim_instance=self.buff_instance.sim_instance):
return False
if skill_node.skill.sp_consume == 0:
return False
self.record.last_update_node = skill_node
return True
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="雨林饕客", sub_exist_buff_dict=1)
sp_consume = self.record.last_update_node.skill.sp_consume
count = math.floor(sp_consume / 10)
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
individule_settled_count=count,
)
# print(f'雨林饕客的buff触发了！当前层数{self.buff_instance.dy.count}')
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/RiotSuppressorMarkVI.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class RiotSuppressorMarkVIRecord:
def __init__(self):
self.equipper = None
self.char = None
self.max_effect_times = 8
self.available_effect_times = 0
self.active_signal = None
self.sub_exist_buff_dict = None
class RiotSuppressorMarkVI(Buff.BuffLogic):
"""防暴者Ⅵ型的复杂逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"防暴者Ⅵ型", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = RiotSuppressorMarkVIRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到强化E和普攻都放行。强化E叠层，普攻消层。"""
self.check_record_module()
self.get_prepared(equipper="防暴者Ⅵ型")
if self.buff_0.dy.active and self.record.available_effect_times < 1:
raise ValueError(f"{self.buff_instance.ft.index}在可用层数耗尽的情况下仍保持激活状态！")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise ValueError(
f"{self.buff_instance.ft.index}的xjudge函数获取的skill_node不是SkillNode类型！"
)
if self.record.char.NAME != skill_node.char_name:
return False
if skill_node.skill.trigger_buff_level not in [2, 0]:
return False
"""Buff的触发，还有生效次数的消耗，都只有在技能释放时才会执行。"""
if skill_node.preload_tick == find_tick(sim_instance=self.buff_instance.sim_instance):
signal = skill_node.skill.trigger_buff_level
if skill_node.skill.trigger_buff_level == 0:
if not self.buff_0.dy.active:
signal = None
else:
signal = None
if signal is not None:
if self.record.active_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数检测到尚未结算的更新信号{self.record.active_signal}！"
)
self.record.active_signal = signal
return True
else:
return False
def special_effect_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="防暴者Ⅵ型", sub_exist_buff_dict=1)
if self.record.active_signal == 2:
"""更新信号为2是时，刷新Buff，叠加生效层数。"""
self.record.available_effect_times = min(
self.record.available_effect_times + self.record.max_effect_times,
self.record.max_effect_times,
)
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
# print(
# f"防暴者VI型Buff触发了！当前可用次数为{self.record.available_effect_times}！"
# )
elif self.record.active_signal == 0:
"""更新信号为0时，消耗层数。"""
if self.record.available_effect_times < 1:
raise ValueError(f"{self.buff_instance.ft.index}的剩余层数不足，无法消耗层数！")
self.record.available_effect_times -= 1
# print(
# f"检测到普攻发动！消耗1层！当前层数为：{self.record.available_effect_times}！"
# )
else:
raise ValueError(
f"{self.buff_instance.ft.index}的Xeffect函数获取到了无法解析的信号{self.record.active_signal}！"
)
self.record.active_signal = None
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="防暴者Ⅵ型")
if self.record.available_effect_times < 1:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/RoaringRideBuffTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class RoaringRideBuffTriggerRecord:
def __init__(self):
self.equipper = None
self.char = None
self.buff_map = None
self.sub_exist_buff_dict = None
class RoaringRideBuffTrigger(Buff.BuffLogic):
"""轰鸣座驾触发器"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xhit = self.special_hit_logic
self.equipper = None
self.buff_0 = None
self.record: RoaringRideBuffTriggerRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"轰鸣座驾", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = RoaringRideBuffTriggerRecord()
self.record = self.buff_0.history.record
def special_hit_logic(self, **kwargs):
"""
轰鸣座驾的判定是简单逻辑，只要是强化E命中即可。
命中后，会执行special_hit函数，该函数会抽取随机数，并且为自己添加对应的Buff
"""
self.check_record_module()
self.get_prepared(equipper="轰鸣座驾", sub_exist_buff_dict=1)
if self.record.buff_map is None:
self.record.buff_map = {
0: f"Buff-武器-精{int(self.buff_instance.ft.refinement)}轰鸣座驾-攻击力",
1: f"Buff-武器-精{int(self.buff_instance.ft.refinement)}轰鸣座驾-精通提升",
2: f"Buff-武器-精{int(self.buff_instance.ft.refinement)}轰鸣座驾-属性异常积蓄",
}
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
from zsim.sim_progress.RandomNumberGenerator import RNG
rng: RNG = self.buff_instance.sim_instance.rng_instance
normalized_value = rng.random_float()
if 0 <= normalized_value < 1 / 3:
buff_add_strategy(self.record.buff_map[0], sim_instance=self.buff_instance.sim_instance)
# print(f'轰鸣座驾触发了攻击力Buff')
elif 1 / 3 <= normalized_value < 2 / 3:
buff_add_strategy(self.record.buff_map[1], sim_instance=self.buff_instance.sim_instance)
# print(f'轰鸣座驾触发了精通Buff')
else:
# print(f'轰鸣座驾触发了积蓄效率Buff')
buff_add_strategy(self.record.buff_map[2], sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedAdditionalAbilityTrigger.py
================================================
# 这是席德额外能力重击大招增伤无视电抗Buff的脚本
from define import SEED_REPORT
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedAdditionalAbilityTriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.cd = 60
self.energy_value = 2 # 回能值，2点能量。
class SeedAdditionalAbilityTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德额外能力给正兵回能的触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedAdditionalAbilityTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
skill_node = kwargs.get("skill_node")
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
assert isinstance(skill_node, SkillNode)
preload_data = self.buff_instance.sim_instance.preload.preload_data
# 当前操作角色不是席德时，直接返回False
if preload_data.operating_now != 1461:
return False
# 过滤掉不是席德的技能
if skill_node.char_name != self.record.char.NAME:
return False
# 过滤掉所有非命中帧
tick = self.buff_instance.sim_instance.tick
if not skill_node.is_hit_now(tick=tick):
return False
# 检查内置CD
if not self.record.check_cd(tick_now=tick):
return False
return True
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert isinstance(self.record, SeedAdditionalAbilityTriggerRecord), (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
assert self.record.char.vanguard is not None, (
"席德在激活了组队被动的情况下没有指定正兵，请检查"
)
vanguard = self.record.char.vanguard
from zsim.sim_progress.data_struct.sp_update_data import ScheduleRefreshData
energy_value = self.record.energy_value
refresh_data = ScheduleRefreshData(
sp_target=(vanguard.NAME,),
sp_value=energy_value,
)
event_list = self.buff_instance.sim_instance.schedule_data.event_list
event_list.append(refresh_data)
self.record.last_active_tick = self.buff_instance.sim_instance.tick
if SEED_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(f"【席德事件】额外能力触发，为{vanguard}回恢 {energy_value} 点能量")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedBesiegeBonus.py
================================================
# 这是席德围杀Buff的脚本
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedBesiegeBonusRecord(BRBC):
def __init__(self):
super().__init__()
class SeedBesiegeBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德围杀Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedBesiegeBonusRecord()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
seed = self.record.char
from zsim.sim_progress.Character.Seed import Seed
assert isinstance(seed, Seed), (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
besiege_tuple = seed.besiege_active_check()
beneficiary = kwargs.get("beneficiary", None)
if beneficiary is None:
print(
f"【Buff退出警告】{self.buff_instance.ft.index} 的复杂逻辑模块未正确识别到输入参数“beneficiary”，遂终止Buff。请检查函数"
)
return True
# 如果席德都没有指定正兵，那么肯定也不可能有围杀Buff
if seed.vanguard is None:
return True
if beneficiary == "席德":
return not besiege_tuple[0]
elif beneficiary == seed.vanguard.NAME:
return not besiege_tuple[1]
else:
# 别的角色不可能保留围杀Buff
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedBesiegeBonusTrigger.py
================================================
# 这是席德围杀Buff的脚本
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedBesiegeBonusTriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.buff_index = "Buff-角色-席德-围杀"
class SeedBesiegeBonusTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德围杀Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedBesiegeBonusTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
from zsim.sim_progress.Character.Seed import Seed
seed = self.record.char
assert isinstance(seed, Seed)
besiege_state_tuple = seed.besiege_active_check()
if any(besiege_state_tuple):
return True
else:
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None
from zsim.sim_progress.Character.Seed import Seed
seed = self.record.char
assert isinstance(seed, Seed)
besiege_state_tuple = seed.besiege_active_check()
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
benefit_list = []
if besiege_state_tuple[0]:
benefit_list.append("席德")
if besiege_state_tuple[1]:
benefit_list.append(seed.vanguard.NAME) if seed.vanguard is not None else None
if benefit_list:
buff_add_strategy(
self.record.buff_index,
benifit_list=benefit_list,
sim_instance=self.buff_instance.sim_instance,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedCinema2BesiegeIgnoreDefenceTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedCinema2BesiegeIgnoreDefenceTriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.buff_index = "Buff-角色-席德-影画-2画-围杀无视防御力"
class SeedCinema2BesiegeIgnoreDefenceTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】角色名字的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedCinema2BesiegeIgnoreDefenceTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
from zsim.sim_progress.Character.Seed import Seed
seed = self.record.char
assert isinstance(seed, Seed)
besiege_state_tuple = seed.besiege_active_check()
if any(besiege_state_tuple):
return True
else:
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None
from zsim.sim_progress.Character.Seed import Seed
seed = self.record.char
assert isinstance(seed, Seed)
besiege_state_tuple = seed.besiege_active_check()
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
benefit_list = []
if besiege_state_tuple[0]:
benefit_list.append("席德")
if besiege_state_tuple[1]:
benefit_list.append(seed.vanguard.NAME) if seed.vanguard is not None else None
if benefit_list:
buff_add_strategy(
self.record.buff_index,
benifit_list=benefit_list,
sim_instance=self.buff_instance.sim_instance,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedCinema2BesiegeIgnoreDefense.py
================================================
# 这是席德2画围杀无视防御力Buff的脚本
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedCinema2BesiegeIgnoreDefenseRecord(BRBC):
def __init__(self):
super().__init__()
class SeedCinema2BesiegeIgnoreDefense(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德2画围杀无视防御力Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedCinema2BesiegeIgnoreDefenseRecord()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
seed = self.record.char
from zsim.sim_progress.Character.Seed import Seed
assert isinstance(seed, Seed), (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
besiege_tuple = seed.besiege_active_check()
beneficiary = kwargs.get("beneficiary", None)
if beneficiary is None:
print(
f"【Buff退出警告】{self.buff_instance.ft.index} 的复杂逻辑模块未正确识别到输入参数“beneficiary”，遂终止Buff。请检查函数"
)
return True
# 如果席德都没有指定正兵，那么肯定也不可能有围杀Buff
if seed.vanguard is None:
return True
if beneficiary == "席德":
return not besiege_tuple[0]
elif beneficiary == seed.vanguard.NAME:
return not besiege_tuple[1]
else:
# 别的角色不可能保留围杀Buff
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedCinema4Bonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedCinema4BonusRecord(BRBC):
def __init__(self):
super().__init__()
self.buff_index = "Buff-角色-席德-影画-4画-喧响效率与大招增伤"
class SeedCinema4Bonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】角色名字的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedCinema4BonusRecord()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
seed = self.record.char
from zsim.sim_progress.Character.Seed import Seed
assert isinstance(seed, Seed), (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
besiege_tuple = seed.besiege_active_check()
beneficiary = kwargs.get("beneficiary", None)
if beneficiary is None:
print(
f"【Buff退出警告】{self.buff_instance.ft.index} 的复杂逻辑模块未正确识别到输入参数“beneficiary”，遂终止Buff。请检查函数"
)
return True
# 如果席德都没有指定正兵，那么肯定也不可能有围杀Buff
if seed.vanguard is None:
return True
if beneficiary == "席德":
return not besiege_tuple[0]
elif beneficiary == seed.vanguard.NAME:
return not besiege_tuple[1]
else:
# 别的角色不可能保留围杀Buff
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedCinema4Trigger.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedCinema4TriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.buff_index = "Buff-角色-席德-影画-4画-喧响效率与大招增伤"
class SeedCinema4Trigger(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】角色名字的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedCinema4TriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
from zsim.sim_progress.Character.Seed import Seed
seed = self.record.char
assert isinstance(seed, Seed)
besiege_state_tuple = seed.besiege_active_check()
if any(besiege_state_tuple):
return True
else:
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None
from zsim.sim_progress.Character.Seed import Seed
seed = self.record.char
assert isinstance(seed, Seed)
besiege_state_tuple = seed.besiege_active_check()
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
benefit_list = []
if besiege_state_tuple[0]:
benefit_list.append("席德")
if besiege_state_tuple[1]:
benefit_list.append(seed.vanguard.NAME) if seed.vanguard is not None else None
if benefit_list:
buff_add_strategy(
self.record.buff_index,
benifit_list=benefit_list,
sim_instance=self.buff_instance.sim_instance,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedCinema6Trigger.py
================================================
from zsim.define import SEED_REPORT
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedCinema6TriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.cd = 180
self.additional_damage_skill_tag = "1461_Cinema_6"
self.trigger_skill_tag = "1461_SNA_1"
class SeedCinema6Trigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德6画触发器Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedCinema6TriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
assert isinstance(skill_node, SkillNode)
if skill_node.skill_tag != self.record.trigger_skill_tag:
return False
tick = self.buff_instance.sim_instance.tick
if tick != skill_node.preload_tick:
return False
if not self.record.check_cd(tick_now=tick):
return False
return True
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None
from zsim.sim_progress.data_struct.SchedulePreload import schedule_preload_event_factory
tick = self.buff_instance.sim_instance.tick
preload_tick_list = [tick, tick, tick]
skill_tag_list = [self.record.additional_damage_skill_tag] * 3
preload_data = self.buff_instance.sim_instance.preload.preload_data
schedule_preload_event_factory(
preload_tick_list=preload_tick_list,
skill_tag_list=skill_tag_list,
preload_data=preload_data,
sim_instance=self.buff_instance.sim_instance,
)
self.record.last_active_tick = tick
if SEED_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print("【席德6画】检测到席德发动了 落华·重戮，添加三次协同攻击！")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedDirectStrikeBonus.py
================================================
# 这是席德明攻Buff的脚本
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedDirectStrikeBonusRecord(BRBC):
def __init__(self):
super().__init__()
self.buff_index = "Buff-角色-席德-明攻"
class SeedDirectStrikeBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德明攻Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xexit = self.special_exit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedDirectStrikeBonusRecord()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
from zsim.sim_progress.Character.Seed import Seed
seed: Seed = self.record.char
if seed.vanguard is None:
# 当席德的没有队友被指定为“正兵”时，明攻永远不可能触发。
return False
# 直接运行席德的围攻状态判断函数
direct_strike = seed.direct_strike_active
return not direct_strike
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedDirectStrikeTrigger.py
================================================
# 这是席德明攻Buff的脚本
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedDirectStrikeTriggerRecord(BRBC):
def __init__(self):
super().__init__()
self.buff_index = "Buff-角色-席德-明攻"
class SeedDirectStrikeTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""这是席德明攻Buff的脚本"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedDirectStrikeTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""判断席德的明攻Buff生效情况"""
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
from zsim.sim_progress.Character.Seed import Seed
seed: Seed = self.record.char
if seed.vanguard is None:
# 当席德的没有队友被指定为“正兵”时，明攻永远不可能触发。
return False
direct_strike = seed.direct_strike_active
# 直接运行席德的围攻状态判断函数
return direct_strike
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1461, sub_exist_buff_dict=1)
assert self.record is not None
seed = self.record.char
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
buff_add_strategy(
self.record.buff_index,
benifit_list=[seed.vanguard.NAME],
sim_instance=self.buff_instance.sim_instance,
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeedOnslaughtBonus.py
================================================
from zsim.sim_progress.Character.Seed import Seed
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class SeedOnslaughtBonusRecord(BRBC):
def __init__(self):
super().__init__()
class SeedOnslaughtBonus(Buff.BuffLogic):
"""席德的强袭Buff复杂逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["席德"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】席德的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = SeedOnslaughtBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""席德的强袭状态早就已经记录在席德的特殊资源中了，所以这里不需要重复判断，只需要直接调用方法判断是否生效即可"""
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
assert type(self.record.char) is Seed, (
f"当前record中的角色不是席德，而是{type(self.record.char).__name__}, CID为：{self.record.char.CID, self.record.char.NAME}"
)
return self.record.char.onslaught_active
def special_exit_logic(self, **kwargs):
"""强袭Buff的退出逻辑和生效逻辑相反，所以这里需要调用席德的方法检测是否退出强袭状态"""
self.check_record_module()
self.get_prepared(char_CID=1461)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
return not self.xjudge
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeveredInnocencELEDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SeveredInnocencELEDMGBonusRecord:
def __init__(self):
self.char = None
self.equipper = None
self.trigger_buff_0 = None
class SeveredInnocencELEDMGBonus(Buff.BuffLogic):
"""
牺牲洁纯的电伤判定
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.equipper = None
self.record = None
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"牺牲洁纯", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SeveredInnocencELEDMGBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""查装备者身上的触发暴伤的Buff是否为3层"""
self.check_record_module()
self.get_prepared(
char_CID=1381,
equipper="牺牲洁纯",
trigger_buff_0=("equipper", "牺牲洁纯-触发暴伤"),
)
if self.record.trigger_buff_0.dy.count == 3:
if not self.record.trigger_buff_0.dy.active:
raise ValueError(f"{self.record.trigger_buff_0.ft.index}有层数但是未激活！")
return True
return False
def special_exit_logic(self, **kwargs):
"""xjudge的反逻辑"""
if self.xjudge:
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SeveredInnocenceCritDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class SeveredInnocenceCritDMGBonusRecord:
def __init__(self):
self.char = None
self.equipper = None
self.update_signal = []
self.active_tick_box = {
0: {"start": 0, "end": 0},
1: {"start": 0, "end": 0},
2: {"start": 0, "end": 0},
}
self.sub_exist_buff_dict = None
class SeveredInnocenceCritDMGBonus(Buff.BuffLogic):
"""
牺牲洁纯的层数判定
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.equipper = None
self.record = None
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"牺牲洁纯", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SeveredInnocenceCritDMGBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
在判断函数阶段，就根据传入的skill_node，进行CID、mission子标签的筛选，
将属于安比的、start子标签的 普攻、特殊技以及追加攻击记录下来，
并且更新进record中的update_signal中
"""
self.check_record_module()
self.get_prepared(char_CID=1381, equipper="牺牲洁纯")
_skill_node = kwargs.get("skill_node", None)
_loading_mission = kwargs.get("loading_mission", None)
if _skill_node is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjudge函数并未获取到skill_node")
if _loading_mission is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjudge函数并未获取到loading_mission")
from zsim.sim_progress.Preload import SkillNode
if not isinstance(_skill_node, SkillNode):
raise TypeError(f"{_skill_node}不是SkillNode类")
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if str(self.record.char.CID) not in _skill_node.skill_tag:
return False
if not tick - 1 < _skill_node.preload_tick <= tick:
return False
if _skill_node.skill.labels is not None:
if "aftershock_attack" in _skill_node.skill.labels.keys():
self.record.update_signal.append(2)
return True
elif _skill_node.skill.trigger_buff_level == 0:
self.record.update_signal.append(0)
return True
elif _skill_node.skill.trigger_buff_level in [1, 2]:
self.record.update_signal.append(1)
return True
else:
return False
def special_start_logic(self, **kwargs):
"""
在正式更新阶段，对update_signal进行pop遍历，把每个signal挨个拿出来进行处理，
并且按照individual_settled类Buff的更新规则，将其转换成built_in_buff_box，并且替换原有的。
最终实现不同Buff层数的管理。
"""
self.check_record_module()
self.get_prepared(char_CID=1381, equipper="牺牲洁纯", sub_exist_buff_dict=1)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if not self.record.update_signal:
return
reset_list = list(set(self.record.update_signal))
while reset_list:
update_signal = reset_list.pop()
self.record.active_tick_box[update_signal]["start"] = tick
self.record.active_tick_box[update_signal]["end"] = (
tick + self.buff_instance.ft.maxduration
)
self.buff_instance.simple_start(tick, self.record.sub_exist_buff_dict, no_count=1)
self.buff_instance.dy.built_in_buff_box = []
for _mode_index, _sub_dict in self.record.active_tick_box.items():
if self.record.active_tick_box[_mode_index]["end"] > tick:
self.buff_instance.dy.built_in_buff_box.append(list(_sub_dict.values()))
self.buff_instance.dy.count = len(self.buff_instance.dy.built_in_buff_box)
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/ShadowHarmony4.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class ShadowHarmony4Record:
def __init__(self):
self.equipper = None
self.char = None
class ShadowHarmony4(Buff.BuffLogic):
"""
这是极地重金属的复杂逻辑判定。
主要检测的是碎冰的变化状态，如果碎冰状态变了，就返回True
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"如影相随", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = ShadowHarmony4Record()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="如影相随")
loading_mission = kwargs.get("loading_mission", None)
if loading_mission is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjuge函数中，获取loading_mission失败")
from zsim.sim_progress.Load import LoadingMission
if not isinstance(loading_mission, LoadingMission):
raise TypeError
skill_node = loading_mission.mission_node
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if not tick - 1 < loading_mission.get_first_hit() <= tick:
"""由于单个技能只能更新本buff一次，而本函数又只能在hit节点执行，
所以这里需要过滤到第一个hit的节点"""
return False
"""是冲刺攻击或是追加攻击标签时，检测技能属性是否与四件套佩戴者属性相同，如果不同则不予触发！"""
if skill_node.element_type != self.record.char.element_type:
return False
if not skill_node.skill.labels:
if skill_node.skill.trigger_buff_level == 3:
return True
else:
if "aftershock_attack" in skill_node.skill.labels.keys():
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SharpenedStingerAnomalyBuildupBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SharpenedStingerAnomalyBuildupBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.update_signal = None
self.preload_data = None
self.sub_exist_buff_dict = None
self.trigger_buff_0 = None
class SharpenedStingerAnomalyBuildupBonus(Buff.BuffLogic):
"""淬锋钳刺第二个特效的判断逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"淬锋钳刺", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SharpenedStingerAnomalyBuildupBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""淬锋钳刺的第二特效触发逻辑：触发器Buff为3层时触发。"""
self.check_record_module()
self.get_prepared(
equipper="淬锋钳刺",
preload_data=1,
trigger_buff_0=("equipper", "淬锋钳刺-猎意"),
)
if self.record.trigger_buff_0.dy.count == 3:
return True
else:
return False
def special_exit_logic(self, **kwargs):
return not self.special_judge_logic(**kwargs)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SharpenedStingerPhyDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class SharpenedStingerPhyDmgBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.update_signal = None
self.preload_data = None
self.sub_exist_buff_dict = None
class SharpenedStingerPhyDmgBonus(Buff.BuffLogic):
"""淬锋钳刺的 猎意复杂逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"淬锋钳刺", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SharpenedStingerPhyDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""淬锋钳刺的猎意触发逻辑。"""
self.check_record_module()
self.get_prepared(equipper="淬锋钳刺", preload_data=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取的skill_node不是SkillNode类！"
)
# 过滤不是自己的skill_node
if self.record.char.NAME != skill_node.char_name:
return False
self.buff_0.ready_judge(find_tick(sim_instance=self.buff_instance.sim_instance))
if not self.buff_0.dy.ready:
return False
if self.record.preload_data.personal_node_stack[self.record.char.CID].__len__() <= 1:
self.record.update_signal = 1
return True
# 判断是否为冲刺攻击或闪避反击
if skill_node.skill.trigger_buff_level not in [3, 4]:
return False
if skill_node.skill.trigger_buff_level in [3]:
self.record.update_signal = 0
elif skill_node.skill.trigger_buff_level == 4:
self.record.update_signal = 1
return True
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="淬锋钳刺", preload_data=1, sub_exist_buff_dict=1)
if self.record.update_signal is None:
return
if self.record.update_signal == 0:
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
elif self.record.update_signal == 1:
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
no_count=1,
)
self.buff_instance.dy.count = self.buff_instance.ft.maxcount
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SliceofTimeExtraResources.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SliceofTimeExtraResourcesRecord:
def __init__(self):
self.equipper = None
self.char = None
self.action_stack = None
self.sub_exist_buff_dict = None
self.decibel_value_dict = {
1: {4: 20, 2: 25, 7: 30, 8: 30, 9: 30, 5: 35},
2: {4: 23, 2: 28.5, 7: 34.5, 8: 34.5, 9: 34.5, 5: 40},
3: {4: 26, 2: 32, 7: 39, 8: 39, 9: 39, 5: 45},
4: {4: 29, 2: 35.5, 7: 43.5, 8: 43.5, 9: 43.5, 5: 50},
5: {4: 32, 2: 40, 7: 48, 8: 48, 9: 48, 5: 55},
}
self.energy_value_dict = {1: 0.7, 2: 0.8, 3: 0.9, 4: 1.0, 5: 1.1}
self.last_update_tick_box = {"E_EX": 0, "Sup": 0, "QTE": 0, "CA": 0}
self.update_key_dict = {
2: "E_EX",
4: "CA",
5: "QTE",
7: "Sup",
8: "Sup",
9: "Sup",
}
class SliceofTimeExtraResources(Buff.BuffLogic):
"""
这是时光切片的复杂效果逻辑。
虽然该buff的buff effect为空，但是在special_start逻辑中，内置了恢复能量和喧响值的方法。
通过构建Schedule Refresh Data的实例，并向event list中添加，
就可以实现角色的喧响值和能量值的修改。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"时光切片", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SliceofTimeExtraResourcesRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
第一层判定是trigger_buff_level的判定
通过第一层判定后，再过内置CD检测。
"""
self.check_record_module()
self.get_prepared(equipper="时光切片", action_stack=1)
action_now = self.record.action_stack.peek()
trigger_buff_level = action_now.mission_node.skill.trigger_buff_level
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
if trigger_buff_level in [4, 2, 7, 8, 9, 5]:
ready = self.check_update_cd(trigger_buff_level, tick_now)
if ready:
return True
else:
return False
else:
return False
def special_start_logic(self, **kwargs):
"""
这部分的代码主要是负责构建一个ScheduleRefreshData实例的，
而simple_start只是为了启动一次，让Log记录到这个buff。
Buff自身没有效果。
"""
self.check_record_module()
self.get_prepared(equipper="时光切片", action_stack=1, sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
action_now = self.record.action_stack.peek()
trigger_buff_level = action_now.mission_node.skill.trigger_buff_level
decibel_value = self.record.decibel_value_dict[self.buff_instance.ft.refinement][
trigger_buff_level
]
energy_value = self.record.energy_value_dict[self.buff_instance.ft.refinement]
actor_name = action_now.mission_character
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
from zsim.sim_progress.data_struct import ScheduleRefreshData
refresh_data = ScheduleRefreshData(
sp_target=(self.record.char.NAME,),
sp_value=energy_value,
decibel_target=(actor_name,),
decibel_value=decibel_value,
)
event_list.append(refresh_data)
def check_update_cd(self, tbl: int, tick_now: int):
"""
检测内置CD！由于闪避反击、强化E、支援技、QTE的触发CD是分开计算的，
所以，这里也要根据trigger buff level进行分流，分别检测各自的CD。
"""
if tbl not in self.record.update_key_dict:
raise ValueError(f"传入的Trigger Buff Level为{tbl}，不在检测范围内！")
key = self.record.update_key_dict[tbl]
last_update_tick = self.record.last_update_tick_box[key]
if last_update_tick == 0:
self.record.last_update_tick_box[key] = tick_now
return True
if tick_now - last_update_tick > self.buff_instance.ft.cd:
self.record.last_update_tick_box[key] = tick_now
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SokakuAdditionalAbilityICEBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SokakuAdditionalAbilityIBRecord:
def __init__(self):
self.char = None
self.action_stack = None
self.last_update_resource = 0
class SokakuAdditionalAbilityICEBonus(Buff.BuffLogic):
"""
苍角组队被动：
消耗涡流发动展旗时激活
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["苍角"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SokakuAdditionalAbilityIBRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1131, action_stack=1)
action_now = self.record.action_stack.peek()
resource_now = self.record.char.get_resources()[1]
if action_now.mission_tag != "1131_E_EX_A":
return False
if self.record.last_update_resource <= resource_now:
self.record.last_update_resource = resource_now
return False
else:
self.record.last_update_resource = resource_now
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SokakuUniqueSkillMajorATKBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SokakuAdditionalAbilityATKRecord:
def __init__(self):
self.dynamic_buff_list = None
self.char = None
self.action_stack = None
self.sub_exist_buff_dict = None
self.last_update_rescource = 0
class SokakuUniqueSkillMajorATKBonus(Buff.BuffLogic):
"""
苍角的核心被动2：消耗涡流的展旗会叠加双倍的攻击力。
程序对苍角的两个Buff是剥离处理的。
Buff1是简单判定逻辑，只要有展旗，就一定触发。
Buff2作为额外的层数，在判定出涡流下降沿时再触发。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xstart = self.special_start_logic
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["苍角"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SokakuAdditionalAbilityATKRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
检测到展旗的TAG后，去查当前的资源数量。
由于执行本代码的阶段是Load阶段，而资源消耗事件是发生在Preload阶段的。
所以，本阶段理论上能够检测到资源的下降沿。
但是由于每次Buff都会新建，所以，这里的self是不能存历史资源的。
必须存放在Buff_0.history.last_update_resource里面。
"""
self.check_record_module()
self.get_prepared(char_CID=1131, action_stack=1)
action_now = self.record.action_stack.peek()
resource_now = self.record.char.get_resources()[1]
if action_now.mission_tag == "1131_E_EX_A":
def match_code(a, b):
return a < b
if JudgeTools.detect_edge(
(resource_now, self.record.last_update_rescource), match_code
):
self.record.last_update_rescource = resource_now
return True
self.record.last_update_rescource = resource_now
return False
def special_start_logic(self, **kwargs):
"""
展旗发动时，应该检索当前角色的面板攻击力。
如果能顺利执行这个模块，那么意味着已经检测到下降沿。
直接调取攻击力并按单倍计算即可。
——————————————————————————
注意，这里不能按照技能说明，用双倍算，
因为这个Buff2只是攻击力Buff的一半，另外一半的层数，在Buff1身上。
"""
self.check_record_module()
self.get_prepared(char_CID=1131, sub_exist_buff_dict=1)
atk_now = self.record.char.statement.ATK
count = min(atk_now * 0.2, 500)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
# 先用simple_start把buff开起来。然后再修改层数。
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SokakuUniqueSkillMinorATKBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SokakuUniqueSkillMinorATKRecord:
def __init__(self):
self.char = None
self.sub_exist_buff_dict = None
class SokakuUniqueSkillMinorATKBonus(Buff.BuffLogic):
"""
这里是苍角的核心被动 1，核心被动1的触发无需复杂代码控制，
只要释放了展旗，就会判定通过。
但是，具体的层数，却是要根据苍角的面板攻击力实时调取的。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xstart = self.special_start_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["苍角"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SokakuUniqueSkillMinorATKRecord()
self.record = self.buff_0.history.record
def special_start_logic(self, **kwargs):
"""
展旗发动时，应该检索当前角色的面板攻击力。
"""
self.check_record_module()
self.get_prepared(char_CID=1131, sub_exist_buff_dict=1)
atk_now = self.record.char.statement.ATK
count = min(atk_now * 0.2, 500)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/Soldier0AnbyAdditionalSkillDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class Soldier0AnbyAdditionalSkillDMGBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
self.preload_data = None
class Soldier0AnbyAdditionalSkillDMGBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
零号·安比的组队被动，操作角色为安比，并且目标有银星时候，全队增伤。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["零号·安比"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = Soldier0AnbyAdditionalSkillDMGBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
只要是检测到有银星，且正在操作安比，就返回True
"""
self.check_record_module()
self.get_prepared(
char_CID=1381,
trigger_buff_0=("零号·安比", "Buff-角色-零号·安比-银星触发器"),
preload_data=1,
)
if self.record.trigger_buff_0.dy.active:
if self.record.preload_data.operating_now == 1381:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/Soldier0AnbyCinema4EleResReduce.py
================================================
from .. import Buff, JudgeTools, check_preparation
class Soldier0AnbyCinema4EleResReduceRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
class Soldier0AnbyCinema4EleResReduce(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
零号·安比的组队被动，操作角色为安比，并且目标有银星时候，全队增伤。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["零号·安比"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = Soldier0AnbyCinema4EleResReduceRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
只要是检测到有银星，就返回True
"""
self.check_record_module()
self.get_prepared(
char_CID=1381,
trigger_buff_0=("零号·安比", "Buff-角色-零号·安比-银星触发器"),
)
if self.record.trigger_buff_0.dy.active:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/Soldier0AnbyCoreSkillCritDMGBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation
class Soldier0AnbyCoreSkillCritDMGBonusRecord:
def __init__(self):
self.char = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
self.trigger_buff_0 = None
class Soldier0AnbyCoreSkillCritDMGBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
零号·安比的核心被动，银星有层数就触发增伤。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["零号·安比"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = Soldier0AnbyCoreSkillCritDMGBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
只要是检测到有银星，就返回True
"""
self.check_record_module()
self.get_prepared(
char_CID=1381,
trigger_buff_0=("零号·安比", "Buff-角色-零号·安比-银星触发器"),
)
if self.record.trigger_buff_0.dy.active:
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""在Buff触发时，读取安比的暴伤，计算当前的层数"""
self.check_record_module()
self.get_prepared(char_CID=1381, dynamic_buff_list=1, enemy=1, sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict, no_count=1)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
crit_dmg = Cal.RegularMul.cal_personal_crit_dmg(mul_data)
count = crit_dmg * 0.3 * 100
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/Soldier0AnbyCoreSkillDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class Soldier0AnbyCoreSkillDMGBonusRecord:
def __init__(self):
self.char = None
self.dynamic_buff_list = None
self.enemy = None
self.sub_exist_buff_dict = None
self.trigger_buff_0 = None
class Soldier0AnbyCoreSkillDMGBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
零号·安比的核心被动，银星有层数就触发增伤。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["零号·安比"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = Soldier0AnbyCoreSkillDMGBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
只要是检测到有银星，就返回True
"""
self.check_record_module()
self.get_prepared(char_CID=1381)
if self.record.char.get_resources()[1] > 0:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/Soldier0AnbySilverStarTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation
class Soldier0AnbySilverStarTriggerRecord:
def __init__(self):
self.char = None
class Soldier0AnbySilverStarTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
零号·安比的核心被动，银星有层数就触发增伤。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xexit = self.special_exit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["零号·安比"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = Soldier0AnbySilverStarTriggerRecord()
self.record = self.buff_0.history.record
def special_exit_logic(self, **kwargs):
"""
只要是检测到银星清0，就返回True
"""
self.check_record_module()
self.get_prepared(char_CID=1381)
if self.record.char.get_resources()[1] == 0:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/Soldier11AdditionalSkillExtraFireDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class Slodier11AdditionalSkillRecord:
def __init__(self):
self.enemy = None
class Soldier11AdditionalSkillExtraFireDMGBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
11号组队被动：失衡期间额外火伤。
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["11号"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = Slodier11AdditionalSkillRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(enemy=1)
if self.record.enemy.dynamic.stun:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SpectralGazeDefReduce.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SpectralGazeDefReduceRecord:
def __init__(self):
self.equipper = None
self.char = None
class SpectralGazeDefReduce(Buff.BuffLogic):
"""扳机专武索魂影眸的减防效果判定"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"索魂影眸", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
"""
这里的初始化，找到的buff_0实际上是佩戴者的buff_0
"""
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SpectralGazeDefReduceRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""装备者的[追加攻击]命中敌人并造成电属性伤害时触发"""
self.check_record_module()
self.get_prepared(equipper="索魂影眸")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjudge中缺少skill_node参数")
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError
if str(self.record.char.CID) not in skill_node.skill_tag or not skill_node.skill.labels:
return False
if skill_node.element_type == 3 and "aftershock_attack" in skill_node.skill.labels:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SpectralGazeImpactBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SpectralGazeImpactBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.trigger_buff_0 = None
class SpectralGazeImpactBonus(Buff.BuffLogic):
"""扳机专武索魂影眸的第3特效——魂锁满层时，获得冲击力增幅，"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"索魂影眸", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
"""
这里的初始化，找到的buff_0实际上是佩戴者的buff_0
"""
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SpectralGazeImpactBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检查触发器buff是否是3层"""
self.check_record_module()
self.get_prepared(equipper="索魂影眸", trigger_buff_0=("equipper", "索魂影眸-魂锁"))
if self.record.trigger_buff_0.dy.active:
if self.record.trigger_buff_0.dy.count == 3:
return True
return False
def special_exit_logic(self, **kwargs):
if not self.xjudge:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SpectralGazeSpiritLock.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class SpectralGazeSpiritLockRecord:
def __init__(self):
self.equipper = None
self.char = None
self.preload_data = None
self.last_update_node_id = None
class SpectralGazeSpiritLock(Buff.BuffLogic):
"""扳机专武索魂影眸第二特效——魂锁，"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"索魂影眸", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
"""
这里的初始化，找到的buff_0实际上是佩戴者的buff_0
"""
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SpectralGazeSpiritLockRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
装备者的[追加攻击]命中敌人并造成电属性伤害时,
若当前角色处于后台（并非主操角色），返回True，
同一招式内最多触发一次（这里利用了skill_node 的一个新增功能：独立ID）
"""
self.check_record_module()
self.get_prepared(equipper="索魂影眸", preload_data=1)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
skill_node = kwargs.get("skill_node")
loading_mission = kwargs.get("loading_mission")
"""逻辑外壳和专武的第一特效没有区别"""
if skill_node is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjudge中缺少skill_node参数")
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError
if not loading_mission.is_hit_now(tick):
return False
if str(self.record.char.CID) not in skill_node.skill_tag:
return False
if not skill_node.skill.labels:
return False
if skill_node.element_type == 3 and "aftershock_attack" in skill_node.skill.labels:
if self.record.preload_data.operating_now != self.record.char.CID:
node_id = skill_node.get_total_instances()
if node_id != self.record.last_update_node_id:
self.record.last_update_node_id = node_id
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/SteamOven.py
================================================
from .. import Buff, JudgeTools, check_preparation
class SteamOvenRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.last_update_count = 0
self.last_update_tick = 0
self.action_stack = None
self.E_EX_started = False
self.E_EX_endtick = 0
class SteamOven(Buff.BuffLogic):
"""
这段代码是人为刀俎的生效逻辑。根据能量返回层数。
由于该效果要求在能量扣除后还能继续存在8秒，且每一层效果单独结算持续时间，
应在每次更新时，都实时检测当前能量，并更新buff.dy.built_in_buff_box中的所有list。
更新方式不是替换，而是类似于栈。
这里不需要管过期tuples的移除，只需要管溢出tuples的移除即可。
注意，这个Buff的复杂判断逻辑永远是False，但是只输出True。
不能用Alltime参数来平替，因为这样会导致在Update_Buff函数中，本Buff会提前被送出循环，而跳过清理过期tuples的步骤。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"人为刀俎", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = SteamOvenRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
由于人为刀俎的Buff实际上是按照all_time的规格在生效的，
但是因为要用复杂逻辑来更新它的实际层数，所以不能用alltime来粗暴处理，
否则，在UpdateBuff阶段，这个Buff会因为all_time参数是True而被筛掉，
从而丧失自我更新、去除过期层数的能力。
"""
return True
def special_effect_logic(self):
"""
真正的逻辑模块，首先是初始化，比如找出char、找到装备使用者等；
然后是检查当前激活情况，如果当前buff尚未被激活，那么需要用simple_start激活一下。
然后检查能量， 确定需要循环的次数（除以10并向下取整）
确定这一次加入的tuple子单元的两个时间点（在单次函数执行过程中所添加的子层数的tuple都是相同的）
"""
self.check_record_module()
self.get_prepared(equipper="人为刀俎", sub_exist_buff_dict=1, action_stack=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
action_now = self.record.action_stack.peek()
char_energy = self.record.char.sp
"""
以下部分的逻辑判定主要是为了规避
第一个动作是强化E时，由于先在Preload阶段扣除了能量，所以在这里无法读取到真正应生效的能量数值，
所以加了这些代码，让这种情况的强化E也能正确享受到人为刀俎的Buff层数。
"""
if "E_EX" in action_now.mission_tag and not self.record.E_EX_started:
self.record.E_EX_endtick = tick_now + action_now.mission_node.skill.ticks
char_energy += action_now.mission_node.skill.sp_consume
self.record.E_EX_started = True
if tick_now >= self.record.E_EX_endtick:
self.record.E_EX_started = False
new_count = char_energy // 10
"""
层数无变化 或 有增长，返回新层数，更新信息；
层数负增长，判断时间，如果大于8秒，则用新层数，更新信息，
否则用老层数，不更新信息。
"""
if new_count >= self.record.last_update_count:
self.record.last_update_count = new_count
self.record.last_update_tick = tick_now
output = new_count
else:
if tick_now - self.record.last_update_tick > 480:
self.record.last_update_count = new_count
self.record.last_update_tick = tick_now
output = new_count
else:
output = self.record.last_update_count
output = min(output, self.buff_instance.ft.maxcount)
# print(new_count, output, (self.last_update_count, self.last_update_tick))
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_instance.dy.count = output
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/StreetSuperstar.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class StreetSuperstarRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.qte_counter = 0
self.max_qte = 3
self.active_signal = None
class StreetSuperstar(Buff.BuffLogic):
"""街头巨星的逻辑核心：任意角色释放QTE叠层、装备者释放大招触发。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xstart = self.special_start_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"街头巨星", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = StreetSuperstarRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="街头巨星")
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取到的skill_node不是SkillNode类型"
)
if not skill_node.preload_tick == find_tick(sim_instance=self.buff_instance.sim_instance):
return False
if skill_node.skill.trigger_buff_level == 5:
self.record.qte_counter = min(self.record.qte_counter + 1, self.record.max_qte)
elif skill_node.skill.trigger_buff_level == 6:
if skill_node.char_name == self.record.char.NAME:
self.record.active_signal = skill_node
return True
return False
def special_start_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="街头巨星", sub_exist_buff_dict=1)
if self.record.qte_counter == 0:
return
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
specified_count=self.record.qte_counter,
no_end=1,
)
self.buff_instance.dy.endticks = (
find_tick(sim_instance=self.buff_instance.sim_instance)
+ self.record.active_signal.skill.ticks
)
self.buff_instance.update_to_buff_0(self.buff_0)
self.record.qte_counter = 0
self.active_signal = None
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/TheVault.py
================================================
from .. import Buff, JudgeTools, check_preparation
class TheVaultRecord:
def __init__(self):
self.equipper = None
self.char = None
self.action_stack = None
class TheVault(Buff.BuffLogic):
"""
聚宝箱的复杂逻辑模块，回能和增伤的判定逻辑都是一样的，
所以它们共用这一个逻辑模块。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"聚宝箱", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
"""
这里的初始化，找到的buff_0实际上是佩戴者的buff_0
"""
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = TheVaultRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
聚宝箱的触发条件：自己的技能、技能命中帧、[强化E、大招、连携技]
"""
self.check_record_module()
self.get_prepared(equipper="聚宝箱", action_stack=1)
from zsim.sim_progress.Preload import SkillNode
skill_node: SkillNode | None = kwargs.get("skill_node", None)
if skill_node is None:
return False
if skill_node.char_name != self.record.char.NAME:
return False
if skill_node.skill.trigger_buff_level not in [2, 5, 6]:
return False
tick = self.buff_instance.sim_instance.tick
if skill_node.is_hit_now(tick):
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/TimeweaverApBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class TimeweaverApBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.enemy = None
class TimeweaverApBonus(Buff.BuffLogic):
"""时流贤者的电属性积蓄相关Buff逻辑。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"时流贤者", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = TimeweaverApBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""时流贤者的电属性积蓄相关Buff的核心逻辑。"""
self.check_record_module()
self.get_prepared(equipper="时流贤者", enemy=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取的skill_node不是SkillNode类！"
)
# 过滤不是自己的skill_node
if self.record.char.NAME != skill_node.char_name:
return False
# 判断skill node的trigger_buff_level是否为1或2
if skill_node.skill.trigger_buff_level not in [1, 2]:
return False
# 判断当前是否是hit节点
if not skill_node.loading_mission.is_hit_now(
find_tick(sim_instance=self.buff_instance.sim_instance)
):
return False
# 判断敌人是否处于异常状态
if not self.record.enemy.dynamic.is_under_anomaly():
return False
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/TimeweaverDisorderDmgMul.py
================================================
from .. import Buff, JudgeTools, check_preparation
class TimeweaverDisorderDmgMulRecord:
def __init__(self):
self.equipper = None
self.char = None
self.preload_data = None
self.dynamic_buff_list = None
self.enemy = None
class TimeweaverDisorderDmgMul(Buff.BuffLogic):
"""时流贤者的精通AP检查相关Buff逻辑。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"时流贤者", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = TimeweaverDisorderDmgMulRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""时流贤者的精通AP检查相关Buff的核心逻辑。"""
self.check_record_module()
self.get_prepared(equipper="时流贤者", preload_data=1, dynamic_buff_list=1, enemy=1)
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
ap = Cal.AnomalyMul.cal_ap(mul_data)
return ap >= 375
def special_exit_logic(self, **kwargs):
return not self.special_judge_logic(**kwargs)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/TriggerAdditionalAbilityStunBonus.py
================================================
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation, find_tick
class TriggerAdditionalAbilityStunBonusRecord:
def __init__(self):
self.char = None
self.sub_exist_buff_dict = None
self.enemy = None
self.dynamic_buff_list = None
class TriggerAdditionalAbilityStunBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""扳机的组队被动，根据暴击率提升失衡值。"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["扳机"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = TriggerAdditionalAbilityStunBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""首先，扳机组队被动的判断逻辑和核心被动没有区别"""
self.check_record_module()
self.get_prepared(char_CID=1361)
from zsim.sim_progress.Preload import SkillNode
skill_node: SkillNode | None
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjudge中缺少skill_node参数")
if "1361" not in skill_node.skill_tag or not skill_node.skill.labels:
return False
if "aftershock_attack" in skill_node.skill.labels.keys():
return True
return False
def special_hit_logic(self, **kwargs):
"""判定通过后，执行Buff激活，计算实时暴击率，替换当前层数。"""
self.check_record_module()
self.get_prepared(char_CID=1361, sub_exist_buff_dict=1, enemy=1, dynamic_buff_list=1)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
crit_rate = Calculator.RegularMul.cal_personal_crit_rate(mul_data)
"""「扳机」的暴击率高于40%时，每超过1%暴击率会使自身发动[追加攻击]造成的失衡值提升1.5%，最多提升75%。"""
count = min(max(crit_rate - 0.4, 0) / 0.01 * 1.5, 75)
# print(f'当前暴击率：{crit_rate}, 层数：{count}')
self.buff_instance.simple_start(tick, self.record.sub_exist_buff_dict, no_count=1)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/TriggerAfterShockTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class TriggerAfterShockTriggerRecord:
def __init__(self):
self.char = None
self.preload_data = None
self.active_signal_mission = None
self.after_shock_manager = None
class TriggerAfterShockTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""扳机的协同攻击触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["扳机"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = TriggerAfterShockTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
触发器的xjudge函数，负责判断当前攻击是否能够触发协同攻击
"""
self.check_record_module()
self.get_prepared(char_CID=1361, preload_data=1)
loading_mission = kwargs.get("loading_mission", None)
if loading_mission is None:
raise ValueError(
f"{self.buff_instance.ft.index}的xjudge函数中，传入的loading_mission为None！"
)
from zsim.sim_progress.Load import LoadingMission
if not isinstance(loading_mission, LoadingMission):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数中，传入的loading_mission类型错误！"
)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
"""如果当前mission不是hit，则不触发"""
if not loading_mission.is_hit_now(tick):
return False
"""如果当前mission是扳机自己的动作，也不触发"""
if "1361" in loading_mission.mission_tag:
return False
"""
剩余情况汇总：队友的、正在命中的skill_node，即为可能触发协同攻击的skill_node，
但是，这里是不包含 扳机 决意值 的判断逻辑的，
因为在after_shock管理器中，决意值不够时会直接返回None。
"""
self.record.active_signal_mission = loading_mission
return True
def special_hit_logic(self, **kwargs):
"""
扳机的协同攻击触发的核心函数，负责抛出对应的协同攻击给Preload，
同时更新角色的决意值、协战状态管理器数据
"""
self.check_record_module()
self.get_prepared(char_CID=1361, preload_data=1)
if self.record.active_signal_mission is None:
raise ValueError(
f"{self.buff_instance.ft.index}的xjudge函数在本tick通过判定，但是并未将通过判定的skill_node传入自身的record中"
)
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
after_shock_tag = self.record.char.after_shock_manager.spawn_after_shock(
tick, self.record.active_signal_mission
)
if after_shock_tag is not None:
insert_tuple = (after_shock_tag, False, 0)
self.record.preload_data.preload_action_list_before_confirm.append(insert_tuple)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/TriggerCoreSkillStunDMGBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class TriggerCoreSkillStunDMGBonusRecord:
def __init__(self):
self.char = None
class TriggerCoreSkillStunDMGBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
"""
扳机的核心被动，扳机发动的追加攻击能增加失衡易伤
"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["扳机"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = TriggerCoreSkillStunDMGBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只要是检测到扳机释放的协同攻击，就返回True"""
self.check_record_module()
self.get_prepared(char_CID=1361)
from zsim.sim_progress.Preload import SkillNode
skill_node: SkillNode | None
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
raise ValueError(f"{self.buff_instance.ft.index}的xjudge并未成功获取到skill_node！")
if "1361" not in skill_node.skill_tag or not skill_node.skill.labels:
return False
if "aftershock_attack" in skill_node.skill.labels.keys():
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianAdditionalAbilityCoAttackTrigger.py
================================================
from zsim.define import VIVIAN_REPORT
from .. import Buff, JudgeTools, check_preparation, find_tick
class VivianAdditionalAbilityCoAttackTriggerRecord:
def __init__(self):
self.char = None
self.last_update_anomaly = None # 上次更新的异常。
self.cd = 30 # 内置CD0.5秒
self.last_update_tick = 0 # 上次更新时间
self.preload_data = None
class VivianAdditionalAbilityCoAttackTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""薇薇安组队被动中的协同攻击触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VivianAdditionalAbilityCoAttackTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到属性异常传入后，进行判定。如果新的异常，则放行。"""
self.check_record_module()
self.get_prepared(char_CID=1331, preload_data=1)
anomaly_bar = kwargs.get("anomaly_bar", None)
if anomaly_bar is None:
return False
from zsim.sim_progress.anomaly_bar import AnomalyBar
if not isinstance(anomaly_bar, AnomalyBar):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取的{anomaly_bar}不是AnomalyBar类！"
)
# 如果是VVA自己触发的异常，则不放行。
if anomaly_bar.activated_by:
if "1331" in anomaly_bar.activated_by.skill_tag:
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print("组队被动：检测到薇薇安触发的属性异常，不放行！")
return False
# 如果是首次传入的属性异常类，则直接放行。
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if self.record.last_update_anomaly is None:
self.record.last_update_anomaly = anomaly_bar
self.record.last_update_tick = tick
return True
# 如果是同一异常，则不放行。
if id(anomaly_bar) == id(self.record.last_update_anomaly):
return False
# CD没转好，不触发。
if tick - self.record.last_update_tick < self.record.cd:
return False
self.record.last_update_anomaly = anomaly_bar
self.record.last_update_tick = tick
return True
def special_effect_logic(self, **kwargs):
"""一旦Xjudge放行，那么就执行本函数，试图生成一次生花。"""
self.check_record_module()
self.get_prepared(char_CID=1361, preload_data=1)
coattack_skill_tag = self.record.char.feather_manager.spawn_coattack()
if coattack_skill_tag is None:
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"组队被动：虽然有{self.record.last_update_anomaly.element_type}类型的新异常触发！但是豆子不够！当前资源情况为：{self.record.char.get_special_stats()}"
)
return
input_tuple = (coattack_skill_tag, False, 0)
self.record.preload_data.external_add_skill(input_tuple)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"组队被动：监听到队友的技能{self.record.last_update_anomaly.activate_by}触发了新的异常，薇薇安触发了一次落雨生花！"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianCinema1Debuff.py
================================================
from .. import Buff, JudgeTools, check_preparation
class VVivianCinema1DebuffRecord:
def __init__(self):
self.char = None
self.enemy = None
class VivianCinema1Debuff(Buff.BuffLogic):
def __init__(self, buff_instance):
"""薇薇安1画的负面效果判定逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VVivianCinema1DebuffRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到敌人身上有薇薇安的预言Dot就放行"""
self.check_record_module()
self.get_prepared(char_CID=1331, enemy=1)
if self.record.enemy.find_dot("ViviansProphecy"):
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianCinema6Trigger.py
================================================
import math
from zsim.define import VIVIAN_REPORT
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation
class VivianCinema6TriggerRecord:
def __init__(self):
self.char = None
self.preload_data = None
self.last_update_node = None
self.enemy = None
self.dynamic_buff_list = None
self.sub_exist_buff_dict = None
self.cinema_ratio = None
self.guard_feather = None
@property
def c6_ratio(self):
return self.guard_feather * 0.8
class VivianCinema6Trigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""薇薇安的核心被动触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.ANOMALY_RATIO_MUL = {
0: 0.0075,
1: 0.08,
2: 0.0108,
3: 0.032,
4: 0.0615,
5: 0.0108,
}
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VivianCinema6TriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
薇薇安的核心被动触发器：
触发机制为：全队任意角色触发属性异常的第一跳时，构造一个新的属性异常放到Evenlist中
"""
self.check_record_module()
self.get_prepared(char_CID=1331, enemy=1)
skill_node = kwargs.get("skill_node", None)
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取到的skill_node不是SkillNode类型！"
)
if skill_node.skill_tag != "1331_SNA_2":
return False
if not self.record.enemy.dynamic.is_under_anomaly:
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(" APL警告：怪物没异常你打什么SNA_2！豆子全没了吧傻子！")
if self.record.last_update_node is None:
self.c6_pre_active(skill_node)
return True
else:
if skill_node.UUID != self.record.last_update_node.UUID:
self.c6_pre_active(skill_node)
return True
return False
def c6_pre_active(self, skill_node):
self.record.last_update_node = skill_node
guard_feather_cost = min(self.record.char.feather_manager.guard_feather, 5)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"6画触发器：检测到【悬落】，即将消耗全部护羽！消耗前的资源情况为：{self.record.char.get_special_stats()}"
)
self.record.guard_feather = guard_feather_cost
self.record.char.feather_manager.guard_feather = 0
self.record.char.feather_manager.c1_counter += guard_feather_cost
while self.record.char.feather_manager.c1_counter >= 4:
self.record.char.feather_manager.c1_counter -= 4
self.record.char.feather_manager.flight_feather = min(
self.record.char.feather_manager.flight_feather + 1, 5
)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"6画触发器：因6画触发、联动1画，恢复一点飞羽！当前资源情况为：{self.record.char.get_special_stats()}"
)
def special_effect_logic(self, **kwargs):
"""当Xjudge检测到AnomalyBar传入时通过判定，并且执行xeffect"""
self.check_record_module()
self.get_prepared(
char_CID=1361,
preload_data=1,
dynamic_buff_list=1,
enemy=1,
sub_exist_buff_dict=1,
)
from zsim.sim_progress.anomaly_bar import AnomalyBar
get_result = self.record.enemy.dynamic.get_active_anomaly()
if not get_result:
self.record.char.feather_manager.update_myself(c6_signal=True)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
"6画触发器：在怪物没有异常的情况下打了【悬落】，虽然不能触发额外的异放，但是依然可以进行羽毛转化！"
)
else:
active_anomaly_bar = get_result[0]
copyed_anomaly = AnomalyBar.create_new_from_existing(active_anomaly_bar)
if not copyed_anomaly.settled:
copyed_anomaly.anomaly_settled()
# copyed_anomaly = self.record.last_update_anomaly
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
ap = Cal.AnomalyMul.cal_ap(mul_data)
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import (
DirgeOfDestinyAnomaly,
)
dirge_of_destiny_anomaly = DirgeOfDestinyAnomaly(
copyed_anomaly,
active_by="1331",
sim_instance=self.buff_instance.sim_instance,
)
ratio = self.ANOMALY_RATIO_MUL.get(copyed_anomaly.element_type)
if self.record.cinema_ratio is None:
self.record.cinema_ratio = 1 if self.record.char.cinema < 2 else 1.3
final_ratio = (
math.floor(ap / 10) * ratio * self.record.cinema_ratio * self.record.c6_ratio
)
dirge_of_destiny_anomaly.anomaly_dmg_ratio = final_ratio
# 在柚叶版本更新后，异常计算的逻辑改变了。current_ndarray不再动态变更，而是在属性异常触发后集中计算。
# 所以，这里获取到的current_ndarray是已经计算好的，所以这里不需要除以当前异常值
# dirge_of_destiny_anomaly.current_ndarray = (
# dirge_of_destiny_anomaly.current_ndarray
# / dirge_of_destiny_anomaly.current_anomaly
# )
event_list.append(dirge_of_destiny_anomaly)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"6画触发器：触发额外异放！本次触发消耗额外护羽数量为：{self.record.guard_feather}，当前资源情况为：{self.record.char.get_special_stats()}"
)
self.record.guard_feather = 0
self.record.char.feather_manager.update_myself(c6_signal=True)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianCoattackTrigger.py
================================================
from zsim.define import VIVIAN_REPORT
from .. import Buff, JudgeTools, check_preparation, find_tick
class VivianCoattackTriggerRecord:
def __init__(self):
self.char = None
self.preload_data = None
self.last_update_node = None
self.JUDGE_MAP = {
"1221_E_EX_1": lambda: self.last_update_node.end_tick
>= find_tick(sim_instance=self.char.sim_instance),
"1221_E_EX_2": lambda: False,
}
class VivianCoattackTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""薇薇安的协同攻击（落雨生花）触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VivianCoattackTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到队友释放强化E并且第一跳命中时放行。"""
self.check_record_module()
self.get_prepared(char_CID=1331, preload_data=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode | LoadingMission):
return
if isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
# 首先过滤所有非强化E标签的技能
if skill_node.skill.trigger_buff_level != 2:
return False
# 过滤所有并非第一跳的技能
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if not skill_node.loading_mission.is_first_hit(tick):
return False
# 如果是首次传入，直接放行
if self.record.last_update_node is None:
self.record.last_update_node = skill_node
return True
else:
# 并非首次传入时，判断是否是同一个技能
if skill_node.UUID == self.record.last_update_node.UUID:
return False
else:
# 若是不同技能，进入最后一个判断分支
if skill_node.skill_tag in self.record.JUDGE_MAP:
result = self.record.JUDGE_MAP[skill_node.skill_tag]()
if result:
self.record.last_update_node = skill_node
else:
return False
else:
self.record.last_update_node = skill_node
return True
def special_effect_logic(self, **kwargs):
"""执行后直接添加一次落雨生花到eventlist——该动作没有动画，所以直接进event_list即可"""
self.check_record_module()
self.get_prepared(char_CID=1361, preload_data=1)
coattack_skill_tag = self.record.char.feather_manager.spawn_coattack()
if coattack_skill_tag is None:
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"【落雨生花】触发器：虽然监听到了队友的强化E：{self.record.last_update_node.skill_tag}，但是豆子不够！当前资源情况为：{self.record.char.get_special_stats()}"
)
return
input_tuple = (coattack_skill_tag, False, 0)
self.record.preload_data.external_add_skill(input_tuple)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"【落雨生花】触发器：监测到强化特殊技{self.record.last_update_node.skill_tag}，薇薇安成功触发了一次落雨生花！(迟滞1tick）"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianCorePassiveTrigger.py
================================================
from zsim.define import VIVIAN_REPORT
from zsim.sim_progress.ScheduledEvent.Calculator import (
Calculator as Cal,
)
from zsim.sim_progress.ScheduledEvent.Calculator import (
MultiplierData as Mul,
)
from .. import Buff, JudgeTools, check_preparation
class VivianCorePassiveTriggerRecord:
def __init__(self):
self.char = None
self.preload_data = None
self.last_update_node = None
self.enemy = None
self.dynamic_buff_list = None
self.sub_exist_buff_dict = None
self.cinema_ratio = None
class VivianCorePassiveTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""薇薇安的核心被动触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.ANOMALY_RATIO_MUL = {
0: 0.0075,
1: 0.08,
2: 0.0108,
3: 0.032,
4: 0.0615,
5: 0.0108,
}
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VivianCorePassiveTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
薇薇安的核心被动触发器：
触发机制为：落羽生花命中处于异常状态的目标时，构造一个新的属性异常放到Evenlist中
"""
self.check_record_module()
self.get_prepared(char_CID=1331, enemy=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取到的skill_node 不是SkillNode类型"
)
if skill_node.skill_tag != "1331_CoAttack_A":
return False
if not self.record.enemy.dynamic.is_under_anomaly():
return False
if self.record.last_update_node is None:
self.record.last_update_node = skill_node
return True
else:
if skill_node.UUID != self.record.last_update_node.UUID:
self.record.last_update_node = skill_node
return True
else:
return False
def special_effect_logic(self, **kwargs):
"""当Xjudge检测到AnomalyBar传入时通过判定，并且执行xeffect"""
self.check_record_module()
self.get_prepared(
char_CID=1361,
preload_data=1,
dynamic_buff_list=1,
enemy=1,
sub_exist_buff_dict=1,
)
from zsim.sim_progress.anomaly_bar import AnomalyBar
get_result = self.record.enemy.dynamic.get_active_anomaly()
if not get_result:
raise ValueError(
f"{self.buff_instance.ft.index}的xeffect函数中，enemy.get_active_anomlay函数返回空列表，说明此时没有异常。但是xjudge函数却放行了。"
)
active_anomaly_bar = get_result[0]
copyed_anomaly = AnomalyBar.create_new_from_existing(active_anomaly_bar)
if not copyed_anomaly.settled:
copyed_anomaly.anomaly_settled()
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
mul_data = Mul(self.record.enemy, self.record.dynamic_buff_list, self.record.char)
ap = Cal.AnomalyMul.cal_ap(mul_data)
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import (
DirgeOfDestinyAnomaly,
)
dirge_of_destiny_anomaly = DirgeOfDestinyAnomaly(
copyed_anomaly,
active_by="1331",
sim_instance=self.buff_instance.sim_instance,
)
ratio = self.ANOMALY_RATIO_MUL.get(copyed_anomaly.element_type)
if self.record.cinema_ratio is None:
self.record.cinema_ratio = 1 if self.record.char.cinema < 2 else 1.3
"""20250424参考波波獭视频，该倍率是每一点精通平滑收益，并非向下取整，故此调整模型，去掉floor。"""
"""final_ratio = math.floor(ap/10) * ratio * self.record.cinema_ratio"""
final_ratio = ap / 10 * ratio * self.record.cinema_ratio
dirge_of_destiny_anomaly.anomaly_dmg_ratio = final_ratio
# dirge_of_destiny_anomaly.current_ndarray = (
# dirge_of_destiny_anomaly.current_ndarray
# / dirge_of_destiny_anomaly.current_anomaly
# )
event_list.append(dirge_of_destiny_anomaly)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print("核心被动：检测到【落羽生花】命中异常状态下的敌人，触发一次异放！！！")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianDotTrigger.py
================================================
from zsim.define import VIVIAN_REPORT
from .. import Buff, JudgeTools, check_preparation, find_tick
class VivianDotTriggerRecord:
def __init__(self):
self.char = None
self.enemy = None
class VivianDotTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""薇薇安的Dot（薇薇安的预言）触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VivianDotTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到敌人处于属性异常状态，并且是SNA2或者是协同攻击时，放行"""
self.check_record_module()
self.get_prepared(char_CID=1331, enemy=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的Xjudge函数获取到的skill_node不是SkillNode类型，请检查！"
)
# 筛选出能够触发dot的SNA_2和生花
if skill_node.skill_tag not in ["1331_SNA_2", "1331_CoAttack_A"]:
return False
# 检测到当前tick有命中时，放行。
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if not skill_node.loading_mission.is_hit_now(tick):
return False
# 如果敌人不处于异常状态，不放行
if not self.record.enemy.dynamic.is_under_anomaly():
return False
return True
def special_hit_logic(self, **kwargs):
"""xjudge放行后，直接生成dot。但是如果dot已经存在，就不重复生成。"""
self.check_record_module()
self.get_prepared(char_CID=1361, enemy=1)
# 如果敌人身上已经存在这个dot，直接不执行
if self.record.enemy.find_dot("ViviansProphecy") is not None:
return
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Update.UpdateAnomaly import spawn_normal_dot
dot = spawn_normal_dot("ViviansProphecy", sim_instance=self.buff_instance.sim_instance)
dot.start(find_tick(sim_instance=self.buff_instance.sim_instance))
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
dot.skill_node_data.loading_mission = LoadingMission(dot.skill_node_data)
dot.skill_node_data.loading_mission.mission_start(
find_tick(sim_instance=self.buff_instance.sim_instance)
)
self.record.enemy.dynamic.dynamic_dot_list.append(dot)
event_list.append(dot.skill_node_data)
if VIVIAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print("核心被动：薇薇安对敌人施加Dot——薇薇安的预言")
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/VivianFeatherTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class VivianFeatherTriggerRecord:
def __init__(self):
self.char = None
self.last_update_node = None
class VivianFeatherTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""管理薇薇安羽毛更新的触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["薇薇安"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = VivianFeatherTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到最后一跳时放行"""
self.check_record_module()
self.get_prepared(char_CID=1331)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Preload import SkillNode
if not isinstance(skill_node, SkillNode):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取的skill_node不是SkillNode类型"
)
# 过滤掉不是自己的skill_node
if "1331" not in skill_node.skill_tag:
return False
# 放行所有正处于最后一跳的skill_node
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if skill_node.loading_mission.is_last_hit(tick):
self.record.last_update_node = skill_node
return True
else:
return False
def special_hit_logic(self, **kwargs):
"""只要触发器放行了，那么special_hit就一定会执行，执行一次后，把record清空即可。"""
self.check_record_module()
self.get_prepared(char_CID=1331)
self.record.char.feather_manager.update_myself(self.record.last_update_node)
self.record.last_update_node = None
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/WeepingCradleDMGBonusIncrease.py
================================================
from .. import Buff, JudgeTools, check_preparation
class WeepingCradleDMGBRecord:
def __init__(self):
self.equipper = None
self.char = None
self.sub_exist_buff_dict = None
self.trigger_buff_0 = None
self.sub_exist_buff_dict = None
self.last_update_tick = 0
class WeepingCradleDMGBonusIncrease(Buff.BuffLogic):
"""
这是啜泣摇篮的自增伤模组。
它需要检测触发器buff [Buff-武器-啜泣摇篮-全队增伤]的 状态来判定自身的状态，这里还涉及一个字符串拼接问题，保证该逻辑能在各个buff中通用。
同时，它还需要判定自身更新的CD，来规避绝无效运算。
判定通过后，它通过special effect来启动，并且进行自叠层。
启动阶段，它的起止时间是触发器buff的时间，这点比较特殊，所以在simple start之后，要修改起止时间并且重新update
而在自叠层阶段，它只修改层数，不修改起止时间。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"啜泣摇篮", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None: # 这里的初始化，找到的buff_0实际上是佩戴者的buff_0，
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = WeepingCradleDMGBRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
trigger_index = f"Buff-武器-精{int(self.buff_instance.ft.refinement)}啜泣摇篮-全队增伤"
self.get_prepared(
equipper="啜泣摇篮",
trigger_buff_0=(self.buff_instance.ft.operator, trigger_index),
)
if self.record.trigger_buff_0.dy.active:
result = self.increase_cd_judge()
if result:
return True
else:
return False
else:
return False
def special_effect_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="啜泣摇篮", sub_exist_buff_dict=1)
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
if not self.buff_0.dy.active:
self.buff_instance.simple_start(tick_now, self.record.sub_exist_buff_dict)
self.buff_instance.dy.startticks = self.record.trigger_buff_0.dy.startticks
self.buff_instance.dy.endticks = self.record.trigger_buff_0.dy.endticks
self.buff_instance.update_to_buff_0(self.buff_0)
else:
self.buff_instance.simple_start(
tick_now, self.record.sub_exist_buff_dict, no_start=True, no_end=True
)
def increase_cd_judge(self):
tick_now = JudgeTools.find_tick(sim_instance=self.buff_instance.sim_instance)
if tick_now - self.record.last_update_tick >= self.buff_instance.ft.cd:
self.record.last_update_tick = tick_now
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/WeepingGeminiApBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation, find_tick
class WeepingGeminiApBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.last_update_anomaly = None
self.enemy = None
self.last_update_stun = False
self.sub_exist_buff_dict = None
class WeepingGeminiApBonus(Buff.BuffLogic):
"""双生泣星的精通增幅判定。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.xexit = self.special_exit_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"双生泣星", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = WeepingGeminiApBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到新属性异常触发，直接放行。"""
self.check_record_module()
self.get_prepared(equipper="双生泣星")
anomaly_bar = kwargs.get("anomaly_bar", None)
if anomaly_bar is None:
return False
from zsim.sim_progress.anomaly_bar import AnomalyBar
if not isinstance(anomaly_bar, AnomalyBar):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge函数获取的{anomaly_bar}不是AnomalyBar类！"
)
if anomaly_bar.activated_by:
if self.record.equipper != anomaly_bar.activated_by.char_name:
return False
if self.record.last_update_anomaly is None:
self.record.last_update_anomaly = anomaly_bar
return True
# 如果是同一异常，则不放行。
if id(anomaly_bar) == id(self.record.last_update_anomaly):
return False
self.record.last_update_anomaly = anomaly_bar
return True
def special_effect_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="双生泣星", enemy=1, sub_exist_buff_dict=1)
self.buff_instance.simple_start(
find_tick(sim_instance=self.buff_instance.sim_instance),
self.record.sub_exist_buff_dict,
)
# print(f'检测到新的异常状态！层数更新！当前层数：{self.buff_instance.dy.built_in_buff_box}')
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="双生泣星", enemy=1)
enemy = self.record.enemy
if self.record.last_update_stun:
if not enemy.dynamic.stun:
self.record.last_update_stun = enemy.dynamic.stun
# print(f'检测到敌人失衡状态的下降沿，Buff清空！')
return True
self.record.last_update_stun = enemy.dynamic.stun
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/WoodpeckerElectroSet4_CA.py
================================================
from __future__ import annotations
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.RandomNumberGenerator import RNG
class WoodpeckerElectroCARecord:
def __init__(self):
self.equipper = None
self.char = None
self.dynamic_buff_list = None
self.enemy = None
self.action_stack = None
class WoodpeckerElectroSet4_CA(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
self.equipper = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"啄木鸟电音", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = WoodpeckerElectroCARecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="啄木鸟电音", enemy=1, dynamic_buff_list=1, action_stack=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
if str(self.record.char.CID) not in skill_node.skill_tag:
return False
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
if skill_node.skill.trigger_buff_level == 4:
rng: RNG = self.buff_instance.sim_instance.rng_instance
normalized_value = rng.random_float()
cric_rate = Calculator.RegularMul.cal_crit_rate(mul_data)
if normalized_value <= cric_rate:
return True
else:
return False
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/WoodpeckerElectroSet4_E_EX.py
================================================
from zsim.sim_progress.RandomNumberGenerator import RNG
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation
class WoodpeckerElectroEXRecord:
def __init__(self):
self.equipper = None
self.char = None
self.dynamic_buff_list = None
self.enemy = None
self.action_stack = None
class WoodpeckerElectroSet4_E_EX(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
self.equipper = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"啄木鸟电音", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = WoodpeckerElectroEXRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="啄木鸟电音", enemy=1, dynamic_buff_list=1, action_stack=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
if str(self.record.char.CID) not in skill_node.skill_tag:
return False
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
if skill_node.skill.trigger_buff_level == 2:
cric_rate = Calculator.RegularMul.cal_crit_rate(mul_data)
rng: RNG = self.buff_instance.sim_instance.rng_instance
normalized_value = rng.random_float()
if normalized_value <= cric_rate:
return True
else:
return False
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/WoodpeckerElectroSet4_NA.py
================================================
from zsim.sim_progress.RandomNumberGenerator import RNG
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
from .. import Buff, JudgeTools, check_preparation
class WoodpeckerElectroNARecord:
def __init__(self):
self.equipper = None
self.char = None
self.dynamic_buff_list = None
self.enemy = None
self.action_stack = None
class WoodpeckerElectroSet4_NA(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
# 初始化特定逻辑
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
self.equipper = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"啄木鸟电音", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = WoodpeckerElectroNARecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="啄木鸟电音", enemy=1, dynamic_buff_list=1, action_stack=1)
skill_node = kwargs.get("skill_node", None)
if skill_node is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(skill_node, SkillNode):
pass
elif isinstance(skill_node, LoadingMission):
skill_node = skill_node.mission_node
else:
return False
if str(self.record.char.CID) not in skill_node.skill_tag:
return False
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
if skill_node.skill.trigger_buff_level == 0:
cric_rate = Calculator.RegularMul.cal_crit_rate(mul_data)
rng: RNG = self.buff_instance.sim_instance.rng_instance
normalized_value = rng.random_float()
if normalized_value <= cric_rate:
return True
else:
return False
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YanagiCinema6EXDmgBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YanagiCinema6EXDmgBonusRecord:
def __init__(self):
self.char = None
class YanagiCinema6EXDmgBonus(Buff.BuffLogic):
"""
柳的6画，森罗万象激活时，通过判定。
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柳"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YanagiCinema6EXDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测当前的森罗万象状态是否开启，若开启则通过判定。"""
self.check_record_module()
self.get_prepared(char_CID=1221)
if self.record.char.get_special_stats()["森罗万象状态"]:
return True
else:
return False
def special_exit_logic(self, **kwargs):
return not self.special_judge_logic(**kwargs)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YanagiPolarityDisorderTrigger.py
================================================
from copy import deepcopy
from .. import Buff, JudgeTools, check_preparation, find_tick
class YanagiPolarityDisorderTriggerRecord:
def __init__(self):
self.char = None
self.enemy = None
self.polarity_disorder_update_signal = (
False # 极性紊乱更新信号：理论上生命周期只有0个tick，本tick放行，本tick处理后重置
)
self.e_counter = {"update_from": "", "count": 0} # 突刺攻击的计数器
self.e_max_count = None # 突刺攻击的最大次数
self.polarity_disorder_basic_dmg_ratio = None # 极性紊乱的基础倍率
self.polarity_disorder_ap_ratio = 32 # 固定的3200%精通倍率
class YanagiPolarityDisorderTrigger(Buff.BuffLogic):
"""
柳的极性紊乱的触发器。
极性紊乱会在强化E下落攻击和Q的最后一个Hit触发，
若是一个招式内同时触发了感电和极性紊乱，则应该先结算感电，再结算极性紊乱；
根据目前ZSim的结构，属性异常检测、属性异常更新、Buff判断循环启动这几个步骤的顺序应该为：
Buff判断循环启动 ——> 触发器启动 ——> 属性异常更新——> 技能伤害计算——> 异常条更新
所以，如果在极性紊乱更新的Tick，同时触发了新的属性异常，
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柳"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YanagiPolarityDisorderTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs) -> bool:
"""
柳的极性紊乱的触发器判断机制，即Enemy身上存在属性异常，就放行，并且向record释放更新信号。
"""
self.check_record_module()
self.get_prepared(char_CID=1221, enemy=1)
obj_input = kwargs.get("skill_node", None)
# 筛选出能够和极性紊乱系统互动的三种技能
if obj_input is None:
return False
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if not isinstance(obj_input, SkillNode | LoadingMission):
raise TypeError(
f"{self.buff_instance.ft.index}的xjudge模块中获取到的{obj_input}不是SkillNode类也不是LoadingMission类！"
)
skill_node = obj_input if isinstance(obj_input, SkillNode) else obj_input.mission_node
if skill_node.skill_tag not in ["1221_E_EX_1", "1221_E_EX_2", "1221_Q"]:
return False
# 正确性判断
if self.record.polarity_disorder_update_signal:
raise ValueError("上一次极性紊乱的更新信号仍旧存在，请检查代码")
# 如果检测到穿刺攻击，则进入对应分支——更新连击次数，但是最后要返回False——因为穿刺攻击无法结算极性紊乱；
if skill_node.skill_tag == "1221_E_EX_1":
# 如果上一次更新的UUID是空，则说明是第一个动作，或者是一个全新的强化E的开始，则直接跳过第一轮分支，进入连击次数更新环节。
if self.record.e_counter["update_from"] == "":
pass
else:
# 如果UUID相同，说明是同一个技能的不同hit，直接返回False
if skill_node.UUID == self.record.e_counter["update_from"]:
return False
if self.record.char.cinema >= 2:
if self.record.e_max_count is None:
self.record.e_max_count = 2 if self.record.char.cinema < 6 else 4
self.record.e_counter["count"] += 1
if self.record.e_counter["count"] >= self.record.e_max_count:
self.record.e_counter["count"] = self.record.e_max_count
self.record.e_counter["update_from"] = skill_node.UUID
return False
# 若是另外两个攻击，则应该检查是否是最后一跳，放行前，打开更新信号。
else:
tick = find_tick(sim_instance=self.buff_instance.sim_instance)
if tick - 1 < skill_node.loading_mission.get_last_hit() <= tick: # 此时就是最后一跳
if self.record.enemy.dynamic.is_under_anomaly(): # 并且存在激活的属性异常
self.record.polarity_disorder_update_signal = True
return True
self.record.e_counter = {"update_from": "", "count": 0}
return False
def special_effect_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1221, enemy=1)
if not self.record.polarity_disorder_update_signal:
raise ValueError("在极性紊乱触发信号未激活时，执行了触发函数！")
# 根据角色命座，初始化基础倍率
if self.record.polarity_disorder_basic_dmg_ratio is None:
self.record.polarity_disorder_basic_dmg_ratio = (
0.15 if self.record.char.cinema < 2 else 0.2
)
# 根据连击次数，计算最终缩放倍率
final_ratio = (
self.record.polarity_disorder_basic_dmg_ratio + 0.15 * self.record.e_counter["count"]
)
# 获取当前正在激活的属性异常条
active_anomaly_bar = self.record.enemy.get_active_anomaly_bar()
active_bar_deep_copy = deepcopy(active_anomaly_bar)
if not active_bar_deep_copy.settled:
active_bar_deep_copy.anomaly_settled()
# 构造极性紊乱对象
from zsim.sim_progress.Update import spawn_output
polarity_disorder_output = spawn_output(
active_bar_deep_copy,
mode_number=2,
polarity_ratio=final_ratio,
skill_node=kwargs["skill_node"],
sim_instance=self.buff_instance.sim_instance,
)
# polarity_disorder_output = spawn_output(active_anomaly_bar, mode_number=1)
# 置入event_list
event_list = JudgeTools.find_event_list(sim_instance=self.buff_instance.sim_instance)
event_list.append(polarity_disorder_output)
# 清空记录，回收更新信号
self.record.e_counter = {"update_from": "", "count": 0}
self.record.polarity_disorder_update_signal = False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YanagiStanceJougen.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YanagiStanceJougenRecord:
def __init__(self):
self.char = None
class YanagiStanceJougen(Buff.BuffLogic):
"""
柳的上弦增幅，检测到上弦状态就通过判定
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柳"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YanagiStanceJougenRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
检测柳的当前状态，如果当前状态为上弦就通过判定。
"""
self.check_record_module()
self.get_prepared(char_CID=1221)
if self.record.char.stance_manager.stance_now:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YanagiStanceKagen.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YanagiStanceKagenRecord:
def __init__(self):
self.char = None
class YanagiStanceKagen(Buff.BuffLogic):
"""
柳的下弦增幅，检测到下弦状态就通过判定
"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柳"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YanagiStanceKagenRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
检测柳的当前状态，如果当前状态为下弦就通过判定。
"""
self.check_record_module()
self.get_prepared(char_CID=1221)
if self.record.char.stance_manager.stance_now:
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YangiCinema1ApBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YangiCinema1ApBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
class YangiCinema1ApBonus(Buff.BuffLogic):
"""柳1画的精通增幅"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柳"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YangiCinema1ApBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""
检测触发器Buff洞悉的层数，层数>= 1 就触发！
"""
self.check_record_module()
self.get_prepared(char_CID=1221, trigger_buff_0=("柳", "Buff-角色-柳-1画-洞悉"))
if self.record.trigger_buff_0.dy.active:
if self.record.trigger_buff_0.dy.count >= 1:
return True
return False
def special_exit_logic(self, **kwargs):
"""退出逻辑和触发逻辑相反！"""
return not self.special_judge_logic(**kwargs)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YixuanAdditionalAbilityDmgBonus.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YIXUAN_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class YixuanAdditionalAbilityDmgBonusRecord:
def __init__(self):
self.char = None
self.trigger_buff_0 = None
class YixuanAdditionalAbilityDmgBonus(Buff.BuffLogic):
"""仪玄组队被动的增伤效果：触发条件是：凝云术和墨烬影消命中失衡状态下的敌人时触发。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["仪玄"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YixuanAdditionalAbilityDmgBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1371)
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
if skill_node is None:
return False
enemy = self.buff_instance.sim_instance.schedule_data.enemy
if not enemy.dynamic.stun:
return False
if "1371_E_EX_B_" not in skill_node.skill_tag:
return False
if skill_node.preload_tick == self.buff_instance.sim_instance.tick:
if YIXUAN_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"仪玄的{skill_node.skill.skill_text}命中了失衡状态下的敌人，触发了组队被动的增伤效果！"
)
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YixuanCinema1Trigger.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YIXUAN_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Character.Yixuan import Yixuan
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
class YixuanCinema1TriggerRecord:
def __init__(self):
self.char = None
self.lighting_strike_skill_tag = "1371_Cinema_1"
self.preload_data = None
self.adrenaline_value = 5
self.sub_exist_buff_dict = None
class YixuanCinema1Trigger(Buff.BuffLogic):
"""仪玄1画的触发器"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["仪玄"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YixuanCinema1TriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""仪玄1画的触发器逻辑，当任意技能命中时放行。"""
self.check_record_module()
self.get_prepared(char_CID=1371)
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
if skill_node is None:
return False
tick = self.buff_instance.sim_instance.tick
if skill_node.char_name == "仪玄":
return False
if skill_node.is_hit_now(tick):
return True
return False
def special_hit_logic(self, **kwargs):
"""向event_list抛出一个落雷以及恢复角色5点闪能值"""
self.check_record_module()
self.get_prepared(char_CID=1221, preload_data=1, sub_exist_buff_dict=1)
preload_data: "PreloadData" = self.record.preload_data
char: "Yixuan" = self.record.char
simulator = self.buff_instance.sim_instance
event_list = simulator.schedule_data.event_list
tick = simulator.tick
# 处理落雷
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload.SkillsQueue import spawn_node
lightning_strick_node: "SkillNode" = spawn_node(
tag=self.record.lighting_strike_skill_tag,
preload_tick=tick,
skills=preload_data.skills,
)
loading_mission = LoadingMission(mission=lightning_strick_node)
loading_mission.mission_start(tick)
lightning_strick_node.loading_mission = loading_mission
event_list.append(lightning_strick_node)
char.update_adrenaline(sp_value=self.record.adrenaline_value)
self.buff_instance.simple_start(
timenow=tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict
)
if YIXUAN_REPORT:
print(
f"1画：生成一道落雷，并且为仪玄回复5点闪能值，仪玄当前闪能值：{char.adrenaline: .2f}"
)
self.buff_instance.sim_instance.schedule_data.change_process_state()
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YixuanCinema2StunTimeLimitBonus.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YIXUAN_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class YixuanCinema2StunTimeLimitBonusRecord:
def __init__(self):
self.char = None
self.enemy = None
self.required_skill_tag = "1371_Q"
class YixuanCinema2StunTimeLimitBonus(Buff.BuffLogic):
"""仪玄2画效果：增加怪物失衡时间"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["仪玄"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YixuanCinema2StunTimeLimitBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1371, enemy=1)
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
if skill_node is None:
return False
if skill_node.skill_tag != self.record.required_skill_tag:
return False
if not self.record.enemy.dynamic.stun:
return False
if skill_node.preload_tick != self.buff_instance.sim_instance.tick:
return False
if YIXUAN_REPORT:
print(
"2画：检测到仪玄释放喧响值大招！敌人正处于失衡状态，2画效果生效，延长敌人3秒失衡时间！"
)
self.buff_instance.sim_instance.schedule_data.change_process_state()
return True
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1371, enemy=1)
if not self.record.enemy.dynamic.stun:
if YIXUAN_REPORT:
print("2画：检测到敌人从失衡状态中恢复，仪玄2画的失衡时间延长效果结束！")
self.buff_instance.sim_instance.schedule_data.change_process_state()
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YixuanCinema4Tranquility.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YIXUAN_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class YixuanCinema4TranquilityRecord:
def __init__(self):
self.char = None
self.update_signal = None
self.sub_exist_buff_dict = None
self.c4_counter = 0 # 静心层数
self.max_c4_count = 2
class YixuanCinema4Tranquility(Buff.BuffLogic):
"""仪玄4画的静心判定逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.xexit = self.special_exit_logic
self.buff_0 = None
self.record: YixuanCinema4TranquilityRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["仪玄"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YixuanCinema4TranquilityRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""仪玄4画的复杂逻辑，当传入技能是仪玄的大招时，叠层；当传入的技能是凝云术时，消耗层数。"""
self.check_record_module()
self.get_prepared(char_CID=1371)
skill_node: "SkillNode | None" = kwargs.get("skill_node", None)
if skill_node is None:
return False
tick = self.buff_instance.sim_instance.tick
if skill_node.char_name != "仪玄":
return False
if skill_node.skill.trigger_buff_level == 6:
# 发动大招时叠层
if skill_node.preload_tick != tick:
return False
if self.record.update_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数的【大招分支】发现record中存在尚未处理的更新信号：{self.record.update_signal}！"
)
self.record.update_signal = 0
return True
else:
# 检测到第二次墨烬影结束消层
if skill_node.skill_tag == "1371_E_EX_B_3":
if skill_node.end_tick != tick:
return False
if self.record.update_signal is not None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xjudge函数的【凝云术分支】发现record中存在尚未处理的更新信号：{self.record.update_signal}！"
)
self.record.update_signal = 1
return True
return False
def special_effect_logic(self, **kwargs):
"""4画的特殊生效逻辑，它根据record中的更新信号（update_signal），有两种模式，一种是叠层，每一种则是消层"""
self.check_record_module()
self.get_prepared(char_CID=1371, sub_exist_buff_dict=1)
if self.record.update_signal is None:
raise ValueError(
f"{self.buff_instance.ft.index}的Xeffect函数执行时，并未检测到有效的更新信号！"
)
sim = self.buff_instance.sim_instance
self.buff_instance.simple_start(
timenow=sim.tick,
sub_exist_buff_dict=self.record.sub_exist_buff_dict,
no_count=1,
)
if self.record.update_signal == 0:
self.record.c4_counter = min(self.record.c4_counter + 1, self.record.max_c4_count)
self.buff_instance.dy.count = self.record.c4_counter
if YIXUAN_REPORT:
print(
f"4画：检测到仪玄释放大招，为仪玄叠加一层静心，当前的静心层数为：{self.record.c4_counter}"
)
self.buff_instance.sim_instance.schedule_data.change_process_state()
elif self.record.update_signal == 1:
# 经过实测，4画在消耗时会一次性消耗全部层数。
if self.record.c4_counter != 0:
if YIXUAN_REPORT:
print(
f"4画：检测到仪玄释放凝云术，本次凝云术消耗{self.record.c4_counter}层静心！"
)
self.buff_instance.sim_instance.schedule_data.change_process_state()
self.record.c4_counter = 0
self.buff_instance.dy.count = self.record.c4_counter
else:
raise ValueError(f"无法解析的更新信号！{self.record.update_signal}")
self.buff_instance.update_to_buff_0(self.buff_0)
self.record.update_signal = None
def special_exit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1371)
if self.record.c4_counter == 0:
if YIXUAN_REPORT:
print("4画：静心层数耗尽！Buff消退！")
self.buff_instance.sim_instance.schedule_data.change_process_state()
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YunkuiTalesSheerAtkBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YunkuiTalesSheerAtkBonusRecord:
def __init__(self):
self.equipper = None
self.char = None
self.trigger_buff_0 = None
class YunkuiTalesSheerAtkBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"云岿如我", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YunkuiTalesSheerAtkBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(
equipper="云岿如我",
trigger_buff_0=(self.equipper, "Buff-驱动盘-云岿如我-四件套-暴击率提升"),
)
trigger_buff_0: Buff = self.record.trigger_buff_0
if trigger_buff_0.dy.active:
if trigger_buff_0.dy.count == 3:
return True
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaAdditionalAbilityAnomalyBuildupBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YuzuhaAdditionalAbilityAnomalyBuildupBonusRecord:
def __init__(self):
self.char = None
self.sub_exist_buff_dict = None
self.dynamic_buff_list = None
self.enemy = None
self.cinema_1_ratio = None
class YuzuhaAdditionalAbilityAnomalyBuildupBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaAdditionalAbilityAnomalyBuildupBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaAdditionalAbilityAnomalyBuildupBonusRecord()
self.record = self.buff_0.history.record
def special_hit_logic(self, **kwargs):
"""buff激活时，根据柚叶的异常掌控计算层数"""
self.check_record_module()
self.get_prepared(char_CID=1411, sub_exist_buff_dict=1, enemy=1, dynamic_buff_list=1)
if self.record.cinema_1_ratio is None:
self.record.cinema_1_ratio = 1 if self.record.char.cinema < 1 else 1.3
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
am = Calculator.AnomalyMul.cal_am(mul_data)
if am < 100:
return
count = min(am - 100, 100) * self.record.cinema_1_ratio
tick = self.buff_instance.sim_instance.tick
self.buff_instance.simple_start(
timenow=tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict, no_count=1
)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(buff_0=self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaAdditionalAbilityAnomalyDmgBonus.py
================================================
from ....define import YUZUHA_REPORT
from .. import Buff, JudgeTools, check_preparation
class YuzuhaAdditionalAbilityAnomalyDmgBonusRecord:
def __init__(self):
self.char = None
self.sub_exist_buff_dict = None
self.dynamic_buff_list = None
self.enemy = None
self.cinema_1_ratio = None
class YuzuhaAdditionalAbilityAnomalyDmgBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaAdditionalAbilityAnomalyDmgBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaAdditionalAbilityAnomalyDmgBonusRecord()
self.record = self.buff_0.history.record
def special_hit_logic(self, **kwargs):
"""buff激活时，根据柚叶的异常掌控计算层数"""
self.check_record_module()
self.get_prepared(char_CID=1411, sub_exist_buff_dict=1, enemy=1, dynamic_buff_list=1)
if self.record.cinema_1_ratio is None:
self.record.cinema_1_ratio = 1 if self.record.char.cinema < 1 else 1.3
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator, MultiplierData
mul_data = MultiplierData(
self.record.enemy, self.record.dynamic_buff_list, self.record.char
)
am = Calculator.AnomalyMul.cal_am(mul_data)
if am < 100:
return
count = min(am - 100, 100) * self.record.cinema_1_ratio
tick = self.buff_instance.sim_instance.tick
self.buff_instance.simple_start(
timenow=tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict, no_count=1
)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(buff_0=self.buff_0)
if YUZUHA_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"【柚叶组队被动】检测到【狸之愿】激活，当前柚叶的异常掌控为{am:.2f}点，共计提供{count * 0.2:.2f}%的异常积蓄效率以及属性异常/紊乱增伤"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaCinem1EleResReduce.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from ...Preload import SkillNode
class YuzuhaCinem1EleResReduceRecord:
def __init__(self):
self.char = None
self.enemy = None
class YuzuhaCinem1EleResReduce(Buff.BuffLogic):
def __init__(self, buff_instance):
"""柚叶的1画，一样是甜蜜惊吓判定逻辑"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaCinem1EleResReduceRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只有两种强化E和大招的重攻击才能触发甜蜜惊吓效果"""
self.check_record_module()
self.get_prepared(char_CID=1411, enemy=1)
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag not in ["1411_E_EX_A", "1411_E_EX_B", "1411_Q"]:
return False
if not skill_node.is_last_hit(tick=self.buff_instance.sim_instance.tick):
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaCinema2Trigger.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YUZUHA_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class YuzuhaCinema2TriggerRecord:
def __init__(self):
self.char = None
self.allowed_skill_tag_list = ["1411_E_EX_A", "1411_E_EX_B", "1411_Q"]
self.skill_node_be_changed = None
self.cd = 1200
self.last_update_tick = None
self.enemy = None
class YuzuhaCinema2Trigger(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaCinema2TriggerRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaCinema2TriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1411, enemy=1)
if self.record.skill_node_be_changed is not None:
raise ValueError("【浮波柚叶2画触发器】存在尚未处理的更新信号！！")
if self.record.enemy.dynamic.stun:
return False
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag not in self.record.allowed_skill_tag_list:
return False
if not self.ready:
return False
tick = self.buff_instance.sim_instance.tick
if not skill_node.is_last_hit(tick=tick):
return False
else:
self.record.skill_node_be_changed = skill_node
return True
@property
def ready(self):
if self.record.last_update_tick is None:
return True
tick = self.buff_instance.sim_instance.tick
if tick - self.record.last_update_tick > self.record.cd:
return True
else:
return False
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1411)
if self.record.skill_node_be_changed is None:
raise ValueError("【浮波柚叶2画触发器】未发现更新信号！！")
skill_node: "SkillNode" = self.record.skill_node_be_changed
skill_node.force_qte_trigger = True
if YUZUHA_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"【柚叶2画】检测到{skill_node.skill_tag}的重攻击即将命中非失衡敌人！修改参数使其能够触发QTE！"
)
self.record.skill_node_be_changed = None
self.record.last_update_tick = self.buff_instance.sim_instance.tick
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaCinema4QuickAssistTrigger.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YUZUHA_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.data_struct.QuickAssistSystem import QuickAssistSystem
from zsim.sim_progress.Preload import SkillNode
class YuzuhaCinema4QuickAssistTriggerRecord:
def __init__(self):
self.char = None
self.allowed_skill_tag_list = [
"1411_Assault_Aid",
"1411_Assault_Aid_A",
"1411_Assault_Aid_B",
]
self.trigger_skill_node = None
class YuzuhaCinema4QuickAssistTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaCinema4QuickAssistTriggerRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaCinema4QuickAssistTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""浮波柚叶的4画触发器——支援突击触发快速支援"""
self.check_record_module()
self.get_prepared(char_CID=1411)
if self.record.trigger_skill_node is not None:
raise ValueError("【柚叶4画触发器】存在尚未处理的快支触发事件！")
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag not in self.record.allowed_skill_tag_list:
return False
tick = self.buff_instance.sim_instance.tick
if not skill_node.is_last_hit(tick=tick):
return False
self.record.trigger_skill_node = skill_node
return True
def special_hit_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1411)
sim_instance = self.buff_instance.sim_instance
QAS: "QuickAssistSystem" = sim_instance.preload.preload_data.quick_assist_system
target_char_obj = sim_instance.char_data.find_next_char_obj(char_now=1411, direction=1)
QAS.force_active_quick_assist(
tick_now=sim_instance.tick,
skill_node=self.record.trigger_skill_node,
char_name=target_char_obj.NAME,
)
if YUZUHA_REPORT:
sim_instance.schedule_data.change_process_state()
print(
f"【柚叶4画】技能 {self.record.trigger_skill_node.skill_tag} 最后一击命中，并且成功激活了 {target_char_obj.NAME} 的快速支援！"
)
self.record.trigger_skill_node = None
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaCinema6SheelTrigger.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YUZUHA_REPORT
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.sim_progress.Character.Yuzuha import Yuzuha
from zsim.sim_progress.Preload import SkillNode
class YuzuhaCinema6SheelTriggerRecord:
def __init__(self):
self.char = None
self.allowed_skill_tag = "1411_Assault_Aid_B"
self.charging_start = False
self.charging_tick = 0
self.sheel_counter = 0
class YuzuhaCinema6SheelTrigger(Buff.BuffLogic):
"""6画的炮弹触发逻辑"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xeffect = self.special_effect_logic
self.buff_0 = None
self.record: YuzuhaCinema6SheelTriggerRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaCinema6SheelTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""模拟蓄力时间"""
self.check_record_module()
self.get_prepared(char_CID=1411)
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag != self.record.allowed_skill_tag:
return False
tick = self.buff_instance.sim_instance.tick
lasting_tick = tick - skill_node.preload_tick
if 0 <= lasting_tick < 24:
return False
else:
self.record.charging_start = True
if self.record.charging_tick >= 24:
char: "Yuzuha" = self.record.char
if char.get_resources()[1] < 1:
return False
else:
return True
else:
if tick == skill_node.end_tick:
self.record.charging_start = False
self.record.sheel_counter = 0
self.record.charging_tick = 0
return False
self.record.charging_tick += 1
return False
def special_effect_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1411)
from zsim.sim_progress.data_struct.SchedulePreload import schedule_preload_event_factory
sim_instance = self.buff_instance.sim_instance
preload_tick_list = [sim_instance.tick]
skill_tag_list = ["1411_Cinema_6"]
preload_data = sim_instance.preload.preload_data
schedule_preload_event_factory(
preload_tick_list=preload_tick_list,
skill_tag_list=skill_tag_list,
preload_data=preload_data,
sim_instance=sim_instance,
)
self.record.sheel_counter += 1
self.record.charging_tick = 0
if YUZUHA_REPORT:
sim_instance.schedule_data.change_process_state()
print(
f"【柚叶6画】检测到正在›蓄力支援突击，将发射1枚炮弹，这是本次蓄力的第{self.record.sheel_counter}枚"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaCinema6SugarBurstMaxTrigger.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YuzuhaCinema6SugarBurstMaxTriggerRecord:
def __init__(self):
self.char = None
self.enemy = None
class YuzuhaCinema6SugarBurstMaxTrigger(Buff.BuffLogic):
"""炮弹命中甜蜜惊吓状态的敌人时，会触发一次彩糖花火·极"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaCinema6SugarBurstMaxTriggerRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaCinema6SugarBurstMaxTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=1411, enemy=1)
skill_node = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag != "1411_Cinema_6":
return False
if self.record.enemy.special_state_manager:
pass
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaCorePassiveSweetScare.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from ...Preload import SkillNode
class YuzuhaCorePassiveSweetScareRecord:
def __init__(self):
self.char = None
self.enemy = None
class YuzuhaCorePassiveSweetScare(Buff.BuffLogic):
def __init__(self, buff_instance):
"""柚叶的甜蜜惊吓判定逻辑（该buff只作为标志物使用！不含任何业务逻辑和实际效果）"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaCorePassiveSweetScareRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只有两种强化E和大招的重攻击才能触发甜蜜惊吓效果"""
self.check_record_module()
self.get_prepared(char_CID=1411, enemy=1)
skill_node: "SkillNode" = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag not in ["1411_E_EX_A", "1411_E_EX_B", "1411_Q"]:
return False
if not skill_node.is_last_hit(tick=self.buff_instance.sim_instance.tick):
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaHardCandyShotTrigger.py
================================================
from typing import TYPE_CHECKING
from .. import Buff, JudgeTools, check_preparation
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
from ...Character.Yuzuha import Yuzuha
from ...Preload import SkillNode
class YuzuhaHardCandyShotTriggerRecord:
def __init__(self):
self.char = None
self.sub_exist_buff_dict = None
self.cd = None
self.last_update_tick = None
self.update_signal = None
class YuzuhaHardCandyShotTrigger(Buff.BuffLogic):
def __init__(self, buff_instance):
"""硬糖射击触发器"""
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.buff_0 = None
self.record = None
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaHardCandyShotTriggerRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""队友的攻击命中时放行"""
self.check_record_module()
self.get_prepared(char_CID=1411)
skill_node: "SkillNode" = kwargs.get("skill_node")
# 筛选出队友的攻击命中
if skill_node is None:
return False
if skill_node.char_name == self.record.char.NAME:
return False
tick = self.buff_instance.sim_instance.tick
if not skill_node.is_hit_now(tick=tick):
return False
char: "Yuzuha" = self.record.char
# 先保证角色有空
sim_instance: "Simulator" = self.buff_instance.sim_instance
if sim_instance.preload.preload_data.char_occupied_check(char_cid=char.CID, tick=tick):
return False
# 再保证甜度点足够
if char.get_resources()[1] < 1:
return False
else:
if self.ready:
self.record.update_signal = skill_node
return True
return False
def special_hit_logic(self, **kwargs):
"""触发硬糖射击，首先要进行一次simple_start保证触发内置CD，然后再执行业务逻辑"""
self.check_record_module()
self.get_prepared(char_CID=1411, sub_exist_buff_dict=1)
char: "Yuzuha" = self.record.char
tick = self.buff_instance.sim_instance.tick
self.buff_instance.simple_start(
timenow=tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict
)
char.spawn_hard_candy_shot(update_signal=self.record.update_signal)
self.record.last_update_tick = tick
self.record.update_signal = None
@property
def ready(self):
if self.record.cd is None:
self.record.cd = 480 if self.record.char.cinema < 2 else 360
if self.record.last_update_tick is None:
return True
if self.buff_instance.sim_instance.tick - self.record.last_update_tick > self.record.cd:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaSugarBurstAnomalyBuildupBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YuzuhaSugarBurstAnomalyBuildupBonusRecord:
def __init__(self):
self.char = None
self.na_skill_level = None
self.skill_tag = "1411_SNA_A"
self.basic_count = 6
self.count_growth_per_level = 1.5
self.sub_exist_buff_dict = None
class YuzuhaSugarBurstAnomalyBuildupBonus(Buff.BuffLogic):
"""柚叶自带Buff——彩糖花火积蓄值提升。由于数值和buff等级挂钩所以需要在这里控制层数；"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaSugarBurstAnomalyBuildupBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaSugarBurstAnomalyBuildupBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只放行彩糖花火"""
self.check_record_module()
self.get_prepared(char_CID=1411)
skill_node = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag != self.record.skill_tag:
return False
if skill_node.preload_tick != self.buff_instance.sim_instance.tick:
return False
else:
return True
def special_hit_logic(self, **kwargs):
"""根据技能等级生成对应层数"""
self.check_record_module()
self.get_prepared(char_CID=1411, na_skill_level=1, sub_exist_buff_dict=1)
self.buff_instance.simple_start(
timenow=self.buff_instance.sim_instance.tick,
sub_exist_buff_dict=self.record.sub_exist_buff_dict,
no_count=1,
)
count = (
self.record.basic_count
+ self.record.na_skill_level * self.record.count_growth_per_level
)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(buff_0=self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaSugarBurstMaxAnomalyBuildupBonus.py
================================================
from .. import Buff, JudgeTools, check_preparation
class YuzuhaSugarBurstMaxAnomalyBuildupBonusRecord:
def __init__(self):
self.char = None
self.na_skill_level = None
self.skill_tag = "1411_SNA_B"
self.basic_count = 6
self.count_growth_per_level = 1.5
self.sub_exist_buff_dict = None
class YuzuhaSugarBurstMaxAnomalyBuildupBonus(Buff.BuffLogic):
"""柚叶自带Buff——彩糖花火·极积蓄值提升。由于数值和buff等级挂钩所以需要在这里控制层数；"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaSugarBurstMaxAnomalyBuildupBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaSugarBurstMaxAnomalyBuildupBonusRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""只放行彩糖花火·极"""
self.check_record_module()
self.get_prepared(char_CID=1411)
skill_node = kwargs.get("skill_node")
if skill_node is None:
return False
if skill_node.skill_tag != self.record.skill_tag:
return False
if skill_node.preload_tick != self.buff_instance.sim_instance.tick:
return False
else:
return True
def special_hit_logic(self, **kwargs):
"""根据技能等级生成对应层数"""
self.check_record_module()
self.get_prepared(char_CID=1411, na_skill_level=1, sub_exist_buff_dict=1)
self.buff_instance.simple_start(
timenow=self.buff_instance.sim_instance.tick,
sub_exist_buff_dict=self.record.sub_exist_buff_dict,
no_count=1,
)
count = (
self.record.basic_count
+ self.record.na_skill_level * self.record.count_growth_per_level
)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(buff_0=self.buff_0)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/YuzuhaTanukiWishAtkBonus.py
================================================
from ....define import YUZUHA_REPORT
from .. import Buff, JudgeTools, check_preparation
class YuzuhaTanukiWishAtkBonusRecord:
def __init__(self):
self.char = None
self.core_passive_ratio = 0.4
self.sub_exist_buff_dict = None
class YuzuhaTanukiWishAtkBonus(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xhit = self.special_hit_logic
self.buff_0 = None
self.record: YuzuhaTanukiWishAtkBonusRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["柚叶"][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = YuzuhaTanukiWishAtkBonusRecord()
self.record = self.buff_0.history.record
def special_hit_logic(self, **kwargs):
"""buff激活时，根据柚叶的场外攻击力计算层数，"""
self.check_record_module()
self.get_prepared(char_CID=1411, sub_exist_buff_dict=1)
tick = self.buff_instance.sim_instance.tick
static_atk = self.record.char.statement.ATK
count = min(static_atk * self.record.core_passive_ratio, self.buff_instance.ft.maxcount)
self.buff_instance.simple_start(
timenow=tick, sub_exist_buff_dict=self.record.sub_exist_buff_dict, no_count=1
)
self.buff_instance.dy.count = count
self.buff_instance.update_to_buff_0(buff_0=self.buff_0)
if YUZUHA_REPORT:
self.buff_instance.sim_instance.schedule_data.change_process_state()
print(
f"【狸之愿】柚叶核心被动触发！柚叶场外站街攻击力为{static_atk:.2f}点，【狸之愿】为队友提供{count:.2f}点攻击力！"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/ZanshinHerbCase.py
================================================
from .. import Buff, JudgeTools, check_preparation
class ZanshinHerbCaseRecord:
def __init__(self):
self.equipper = None
self.char = None
self.listener_exist = False
self.listener = None
class ZanshinHerbCase(Buff.BuffLogic):
"""激素朋克的复杂逻辑模块，检测到监听器更新信号时更新。"""
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"残心青囊", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = ZanshinHerbCaseRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
"""检测到更新信号时，返回True，并且置空监听器的active_signal。"""
self.check_record_module()
self.get_prepared(equipper="残心青囊")
if not self.record.listener_exist:
self.record.listener = self.buff_instance.sim_instance.listener_manager.get_listener(
listener_owner=self.record.char, listener_id="Zanshin_Herb_Case_1"
)
self.record.listener_exist = True
# print(f"为{self.record.char.NAME}创建了一个残心青囊的监听器！")
active_signal = self.record.listener.active_signal
if active_signal is None:
return False
else:
"""置空信号"""
self.record.listener.listener_active()
print("检测到残心青囊 的触发信号！触发第三特效！")
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/__init__.py
================================================
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/_buff_record_base_class.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from ...Character.Alice import Alice
from ...Character.character import Character
from ...Character.Seed import Seed
from ...Character.Yixuan import Yixuan
from ...data_struct.ActionStack import ActionStack
from ...Enemy import Enemy
from ...Preload.PreloadDataClass import PreloadData
from ..buff_class import Buff
class BuffRecordBaseClass:
def __init__(self):
self.char: "Character | None | Alice | Yixuan | Seed" = None
self.sub_exist_buff_dict: dict[str, "Buff"] | None = None
self.dynamic_buff_list: dict[str, list] | None = None
self.enemy: "Enemy | None" = None
self.equipper: "str | None" = None
self.action_stack: "ActionStack | None" = None
self.event_list: list | None = None
self.preload_data: "PreloadData | None" = None
self.char_obj_list: "list[Character] | None" = None
self.na_skill_level: "int | None" = None
self.trans_ratio: float = 0
self.cd: int = 60 # 内置CD：1秒一次
self.last_active_tick: int = 0 # 上次触发的时间点
self.buff_index: str | None = None
self.trigger_buff_0: "Buff | None" = None
self.additional_damage_skill_tag: str | None = None
self.trigger_skill_tag: str | None = None
def check_cd(self, tick_now: int):
"""检查内置CD是否就绪"""
if self.cd == 0:
return True
if tick_now - self.last_active_tick < self.cd:
return False
else:
return True
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/_char_buff_mod.py
================================================
from .. import Buff, JudgeTools, check_preparation
from ._buff_record_base_class import BuffRecordBaseClass as BRBC
class CharBuffXLogicNameRecord(BRBC):
def __init__(self):
super().__init__()
class CharBuffXLogicName(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.buff_0: "Buff | None" = None
self.record: BRBC | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)["角色名字"][self.buff_instance.ft.index]
assert self.buff_0 is not None, (
"【Buff初始化警告】角色名字的复杂逻辑模块未正确初始化，请检查函数"
)
if self.buff_0.history.record is None:
self.buff_0.history.record = CharBuffXLogicNameRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(char_CID=0000)
assert self.record is not None, (
f"【Buff初始化警告】{self.buff_instance.ft.index}的复杂逻辑模块未正确初始化，请检查函数"
)
================================================
FILE: zsim/sim_progress/Buff/BuffXLogic/_euipment_buff_mod.py
================================================
from .. import Buff, JudgeTools, check_preparation
class BuffXLogicNameRecord:
def __init__(self):
self.equipper = None
self.char = None
class BuffXLogicName(Buff.BuffLogic):
def __init__(self, buff_instance):
super().__init__(buff_instance)
self.buff_instance: Buff = buff_instance
self.xjudge = self.special_judge_logic
self.equipper = None
self.buff_0 = None
self.record: BuffXLogicNameRecord | None = None
def get_prepared(self, **kwargs):
return check_preparation(buff_instance=self.buff_instance, buff_0=self.buff_0, **kwargs)
def check_record_module(self):
if self.equipper is None:
self.equipper = JudgeTools.find_equipper(
"装备名字", sim_instance=self.buff_instance.sim_instance
)
if self.buff_0 is None:
self.buff_0 = JudgeTools.find_exist_buff_dict(
sim_instance=self.buff_instance.sim_instance
)[self.equipper][self.buff_instance.ft.index]
if self.buff_0.history.record is None:
self.buff_0.history.record = BuffXLogicNameRecord()
self.record = self.buff_0.history.record
def special_judge_logic(self, **kwargs):
self.check_record_module()
self.get_prepared(equipper="装备名字")
================================================
FILE: zsim/sim_progress/Buff/JudgeTools/DetectEdges.py
================================================
def detect_edge(pair, mode_func):
# 使用自定义的mode_func函数来判断是否为上升沿或下降沿
return mode_func(pair[0], pair[1])
================================================
FILE: zsim/sim_progress/Buff/JudgeTools/FindCharFromCID.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
def find_char_from_CID(CID: int, sim_instance: "Simulator"):
char_list = sim_instance.char_data.char_obj_list
for char in char_list:
if char.CID == CID:
return char
else:
raise ValueError(f"并未找到CID为{CID}的角色！")
================================================
FILE: zsim/sim_progress/Buff/JudgeTools/FindCharFromName.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
def find_char_from_name(NAME: str, sim_instance: "Simulator | None" = None):
assert sim_instance is not None, "sim_instance不能为空"
char_list = sim_instance.char_data.char_obj_list
for _ in char_list:
if _.NAME == NAME:
return _
else:
raise ValueError(f"未找到名为{NAME}的角色")
================================================
FILE: zsim/sim_progress/Buff/JudgeTools/FindEquipper.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
def find_equipper(item_name: str, sim_instance: "Simulator" = None):
"""
该函数用来找佩戴装备的人，但是需要注意，这个函数处理不了多个人同时佩戴同一件装备的情况。
"""
Judge_list_set = sim_instance.init_data.Judge_list_set
if "二件套" not in item_name:
"""默认找的是四件套 和武器"""
for sub_list in Judge_list_set:
for i in sub_list:
if i == item_name and i != sub_list[3]:
return sub_list[0]
else:
"""找的是二件套"""
for sub_list in Judge_list_set:
for i in sub_list:
if i == item_name and i == sub_list[3]:
return sub_list[0]
================================================
FILE: zsim/sim_progress/Buff/JudgeTools/FindMain.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
def find_enemy(sim_instance: "Simulator" = None):
enemy = sim_instance.schedule_data.enemy
return enemy
def find_init_data(sim_instance: "Simulator" = None):
init_data = sim_instance.init_data
return init_data
def find_char_list(sim_instance: "Simulator" = None):
char_list = sim_instance.char_data.char_obj_list
return char_list
def find_dynamic_buff_list(sim_instance: "Simulator" = None):
dynamic_buff_list = sim_instance.global_stats.DYNAMIC_BUFF_DICT
return dynamic_buff_list
def find_tick(sim_instance: "Simulator" = None):
tick = sim_instance.tick
return tick
def find_exist_buff_dict(sim_instance: "Simulator" = None):
exist_buff_dict = sim_instance.load_data.exist_buff_dict
return exist_buff_dict
def find_event_list(sim_instance: "Simulator" = None):
event_list = sim_instance.schedule_data.event_list
return event_list
def find_stack(sim_instance: "Simulator" = None):
stack = sim_instance.load_data.action_stack
return stack
def find_load_data(sim_instance: "Simulator" = None):
load_data = sim_instance.load_data
return load_data
def find_schedule_data(sim_instance: "Simulator" = None):
schedule_data = sim_instance.schedule_data
return schedule_data
def find_preload_data(sim_instance: "Simulator" = None):
preload_data = sim_instance.preload.preload_data
return preload_data
def find_name_box(sim_instance: "Simulator" = None):
name_box = sim_instance.load_data.name_box
return name_box
def find_all_name_order_box(sim_instance: "Simulator" = None):
all_name_order_box = sim_instance.load_data.all_name_order_box
return all_name_order_box
================================================
FILE: zsim/sim_progress/Buff/JudgeTools/__init__.py
================================================
from typing import TYPE_CHECKING
from .DetectEdges import detect_edge # noqa: F401
from .FindCharFromCID import find_char_from_CID
from .FindCharFromName import find_char_from_name
from .FindEquipper import find_equipper
from .FindMain import (
find_all_name_order_box, # noqa: F401
find_char_list,
find_dynamic_buff_list,
find_enemy,
find_event_list,
find_exist_buff_dict,
find_init_data, # noqa: F401,
find_preload_data,
find_stack,
find_tick, # noqa: F401
)
if TYPE_CHECKING:
from .. import Buff
def check_preparation(
buff_0: "Buff | None",
buff_instance: "Buff",
equipper: str | None = None,
char_CID: int | None = None,
char_NAME: str | None = None,
**kwargs,
):
"""
这是一个综合函数。根据传入的参数，来执行不同的内容。
"""
# 先决条件检查
assert buff_0 is not None, "buff_0不能为空"
if buff_0.history.record is None:
raise ValueError("buff_0的record模块尚未初始化！！！")
record = buff_0.history.record
# 参数获取
enemy = kwargs.get("enemy")
sub_exist_buff_dict = kwargs.get("sub_exist_buff_dict")
dynamic_buff_list = kwargs.get("dynamic_buff_list")
action_stack = kwargs.get("action_stack")
event_list = kwargs.get("event_list")
trigger_buff_0 = kwargs.get("trigger_buff_0")
preload_data = kwargs.get("preload_data")
char_obj_list = kwargs.get("char_obj_list")
na_skill_level = kwargs.get("na_skill_level")
# 参数正确性检查
if sub_exist_buff_dict and char_NAME is None and char_CID is None and equipper is None:
raise ValueError(
"在查询sub_exist_buff_dict的同时，应保证传入char_CID/char_NAME/equipper中的一个参数"
)
if trigger_buff_0 and trigger_buff_0[0] == "enemy" and not any([char_CID, char_NAME, equipper]):
raise ValueError(
"在查询来自于enemy的trigger_buff_0的同时，应保证传入char_CID/char_NAME/equipper中的一个参数"
)
# 函数主体部分
if equipper:
if record.equipper is None:
record.equipper = find_equipper(equipper, sim_instance=buff_instance.sim_instance)
if record.char is None:
assert record.equipper is not None, "equipper不能为空"
record.char = find_char_from_name(
NAME=record.equipper, sim_instance=buff_instance.sim_instance
)
if char_CID:
if record.char is None:
record.char = find_char_from_CID(char_CID, sim_instance=buff_instance.sim_instance)
if char_NAME:
if record.char is None:
record.char = find_char_from_name(char_NAME, sim_instance=buff_instance.sim_instance)
if sub_exist_buff_dict:
if record.char is None:
raise ValueError("在buff_0.history.record 中并未读取到对应的char")
if record.sub_exist_buff_dict is None:
record.sub_exist_buff_dict = find_exist_buff_dict(
sim_instance=buff_instance.sim_instance
)[record.char.NAME]
if enemy:
if record.enemy is None:
record.enemy = find_enemy(sim_instance=buff_instance.sim_instance)
if dynamic_buff_list:
if record.dynamic_buff_list is None:
record.dynamic_buff_list = find_dynamic_buff_list(
sim_instance=buff_instance.sim_instance
)
if action_stack:
if record.action_stack is None:
record.action_stack = find_stack(sim_instance=buff_instance.sim_instance)
if event_list:
# print('event_list放在record中很有可能不会随动！！注意！')
if record.event_list is None:
record.event_list = find_event_list(sim_instance=buff_instance.sim_instance)
if trigger_buff_0:
trigger_buff_0_handler(record, trigger_buff_0, buff_instance=buff_instance)
if preload_data:
if record.preload_data is None:
record.preload_data = find_preload_data(sim_instance=buff_instance.sim_instance)
if char_obj_list:
if record.char_obj_list is None:
record.char_obj_list = find_char_list(sim_instance=buff_instance.sim_instance)
if na_skill_level:
if record.char is None:
raise ValueError("在buff_0.history.record 中并未读取到对应的char")
record.na_skill_level = record.char.skill_object.skill_level_dict.get("normal")
def trigger_buff_0_handler(record, trigger_buff_0, buff_instance: "Buff"):
"""
该函数用于寻找trigger_buff_0，在搜索不同的触发器Buff‘时，程序所面临的情况往往是复杂的。
1、触发器的操作者（operator）和受益者（beneficiary）都是本人的，那么传入的数据直接可以使用；
2、触发器Buff来自于装备者的，其操作者不是一个固定人选，所以需要先找到equipper，再替换操作者；
3、触发器的操作者和受益者不同的（比如目标Buff是一个debuff，存在于Enemy身上），此时，应该传入Operator
——原因是，Buff只有在自身是主视角的时候，才会执行触发，由于模拟器内没有Enemy的主视角，所以，Enemy所有的buff都是需要别的角色来添加的，
所以，应该直接找到活跃的Buff源——也就是Buff 的Operator的源头。
"""
if not isinstance(trigger_buff_0, tuple):
raise TypeError("输入的参数必须是tuple！")
if record.trigger_buff_0 is None:
operator = trigger_buff_0[0]
buff_index = trigger_buff_0[1]
if operator == "equipper":
if record.equipper is None:
record.equipper = find_equipper(operator, sim_instance=buff_instance.sim_instance)
# FIXME:这里要解决传入的operator 是“equipper”字符串的问题！！！！虽然该分支不会被执行，所以从未出错（obsidian笔记详解一下）
operator = record.equipper
elif operator == "enemy":
operator = record.char.NAME
sub_exist_buff_dict = find_exist_buff_dict(sim_instance=buff_instance.sim_instance)[
operator
]
founded_list = []
for _buff_founded in sub_exist_buff_dict.values():
if buff_index in _buff_founded.ft.index:
founded_list.append(_buff_founded)
if len(founded_list) != 1:
"""说明提供的关键词筛选出了多个Buff，此时需要进一步筛选出正确结果"""
founded_buff_index_list = [founded_buff.ft.index for founded_buff in founded_list]
"""验错环节"""
if len(set(founded_buff_index_list)) != len(founded_list):
raise ValueError(f"在{operator}的sub_exist_buff_dict中找到了2个以上的同名buff！")
trigger_index_length = len(buff_index)
for _buffs in founded_list:
if _buffs.ft.index[-trigger_index_length:] == buff_index:
record.trigger_buff_0 = _buffs
break
else:
raise ValueError(
f"并未找到Buff名后缀为{buff_index}的触发器Buff，说明提供的用于寻找trigger_buff_0的关键词无法有效筛选出触发器，请调整关键词或者数据库Buff Index"
)
else:
record.trigger_buff_0 = founded_list[0]
================================================
FILE: zsim/sim_progress/Buff/ScheduleBuffSettle.py
================================================
from __future__ import annotations
from typing import TYPE_CHECKING
from . import JudgeTools
from .buff_class import Buff
from .BuffAdd import add_debuff_to_enemy
if TYPE_CHECKING:
from zsim.sim_progress.Load import LoadingMission
from zsim.simulator.simulator_class import Simulator
def ScheduleBuffSettle(
time_tick: int,
exist_buff_dict: dict,
enemy,
DYNAMIC_BUFF_DICT: dict,
action_stack,
sim_instance: Simulator,
**kwargs,
):
"""
专门用于处理Schedule阶段才能处理的Buff（buff.ft.schedule_judge = True）
此类Buff往往需要当前Tick的结果出来之后再判定触发与否；
"""
preload_data = JudgeTools.find_preload_data(sim_instance=sim_instance)
action_result = None
if "anomaly_bar" in kwargs:
anomaly_bar = kwargs["anomaly_bar"]
if anomaly_bar.activated_by is not None:
action_result = anomaly_bar.activated_by
elif "skill_node" in kwargs:
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
skill_node = kwargs["skill_node"]
if isinstance(skill_node, SkillNode):
action_result = skill_node
elif isinstance(skill_node, LoadingMission):
action_result = skill_node.mission_node
else:
print(f"ScheduleBuffSettle函数接收到了无法识别的event类型{type(skill_node).__name__}")
return
if action_result is None:
action_now = preload_data.get_on_field_node(time_tick)
else:
action_now = action_result
if action_now is None:
print("Warnning！！！ScheduleBuffSettle函数没有找到action_now！")
# FIXME: 修复这个问题！！！
return
char_on_field = action_now.char_name
all_name_order_box = JudgeTools.find_all_name_order_box(sim_instance=sim_instance)
name_box_on_field = all_name_order_box[char_on_field]
for char_name in name_box_on_field:
sub_exist_buff_dict = exist_buff_dict[char_name]
if char_name == "enemy":
continue
elif char_name == char_on_field:
process_schedule_on_field_buff(
sub_exist_buff_dict,
name_box_on_field,
time_tick,
DYNAMIC_BUFF_DICT,
enemy,
**kwargs,
)
else:
process_schedule_backend_buff(
sub_exist_buff_dict,
all_name_order_box,
time_tick,
DYNAMIC_BUFF_DICT,
enemy,
**kwargs,
)
def process_schedule_on_field_buff(
sub_exist_buff_dict: dict,
name_box_now: list,
time_tick: int,
DYNAMIC_BUFF_DICT: dict,
enemy,
**kwargs,
):
"""
用来处理schedule阶段的前台buff。这里特殊说明一下name_box_now的情况
这个list取自当前的init_data下的namebox，是经过顺序变化的、只适用于前台角色第一视角的name_box
所以，这个box只能传入本函数， 为前台角色处理前台buff使用，在处理后台buff的函数中，
应该获取的是all_name_order_box，并从中提取出对应的name_box
"""
for buff in sub_exist_buff_dict.values():
ArgumentCheck(buff=buff)
if not buff.ft.schedule_judge:
continue
if buff.ft.passively_updating:
continue
# Buff判定
all_match = buff.logic.xjudge(**kwargs)
if not all_match:
continue
# Buff 激活
adding_buff_code = str(int(buff.ft.add_buff_to)).zfill(4)
selected_characters = [
name_box_now[i] for i in range(len(name_box_now)) if adding_buff_code[i] == "1"
]
# if buff.ft.index == 'Buff-武器-精1啜泣摇篮-全队增伤自增长':
# print(f'onfield函数处理了这个buff！当前的namebox是：{name_box_now}')
add_schedule_buff(
selected_characters,
buff,
time_tick,
sub_exist_buff_dict,
DYNAMIC_BUFF_DICT,
enemy,
**kwargs,
)
def process_schedule_backend_buff(
sub_exist_buff_dict: dict,
all_name_order_box: dict,
time_tick: int,
DYNAMIC_BUFF_DICT: dict,
enemy,
**kwargs,
):
"""
用来处理schedule阶段的后台buff。
"""
for buff in sub_exist_buff_dict.values():
ArgumentCheck(buff=buff)
if not buff.ft.schedule_judge:
continue
if not buff.ft.backend_acitve:
continue
if buff.ft.passively_updating:
continue
all_match = buff.logic.xjudge(**kwargs)
if not all_match:
continue
main_char = buff.ft.operator
name_box_now = all_name_order_box[main_char]
adding_buff_code = str(int(buff.ft.add_buff_to)).zfill(4)
selected_characters = [
name_box_now[i] for i in range(len(name_box_now)) if adding_buff_code[i] == "1"
]
# if buff.ft.index == 'Buff-武器-精1啜泣摇篮-全队增伤自增长':
# print(f'backend函数处理了这个buff！当前的namebox是：{name_box_now}')
add_schedule_buff(
selected_characters,
buff,
time_tick,
sub_exist_buff_dict,
DYNAMIC_BUFF_DICT,
enemy,
**kwargs,
)
def add_schedule_buff(
selected_characters: list,
buff: Buff,
time_tick: int,
sub_exist_buff_dict: dict,
DYNAMIC_BUFF_DICT: dict,
enemy,
**kwargs,
):
"""
Schedule阶段用来直接添加buff的函数
"""
if not buff.ft.schedule_judge:
raise ValueError(f"{buff.ft.index}不是schedule阶段buff！")
for characters in selected_characters:
buff_new = Buff.create_new_from_existing(buff)
buff_new.ft.operator = buff.ft.operator
buff_new.ft.passively_updating = buff.ft.passively_updating
# if buff.ft.index == 'Buff-武器-精1啜泣摇篮-全队增伤自增长':
# print(f'buff_0情况：{buff.dy.startticks, buff.dy.endticks}')
# print(f'新buff情况：{buff_new.dy.startticks, buff_new.dy.endticks}')
# if not buff.ft.operator == characters:
# continue
if buff.ft.simple_effect_logic:
buff_new.simple_start(time_tick, sub_exist_buff_dict)
else:
buff_new.logic.xeffect(**kwargs)
# Buff加载
buff_existing_check = next(
(
existing_buff
for existing_buff in DYNAMIC_BUFF_DICT[characters]
if existing_buff.ft.index == buff.ft.index
),
None,
)
if buff_existing_check:
DYNAMIC_BUFF_DICT[characters].remove(buff_existing_check)
DYNAMIC_BUFF_DICT[characters].append(buff_new)
if characters == "enemy":
buff_existing_check = next(
(
existing_buff
for existing_buff in enemy.dynamic.dynamic_debuff_list
if existing_buff.ft.index == buff.ft.index
),
None,
)
if buff_existing_check:
enemy.dynamic.dynamic_debuff_list.remove(buff_existing_check)
add_debuff_to_enemy(buff_new, characters, enemy)
def ArgumentCheck(**kwargs):
action_now = kwargs.get("action_now", None)
buff = kwargs.get("buff", None)
if action_now:
if not isinstance(action_now, LoadingMission):
raise TypeError(f"{action_now}不是LoadingMission类！")
if buff:
if not isinstance(buff, Buff):
raise TypeError(f"{buff}不是Buff类！")
if __name__ == "__main__":
pass
================================================
FILE: zsim/sim_progress/Buff/__init__.py
================================================
from .Buff0Manager import Buff0Manager # noqa: F401
from .buff_class import Buff, spawn_buff_from_index # noqa: F401
from .BuffAdd import buff_add # noqa: F401
from .BuffLoad import BuffInitialize, BuffLoadLoop # noqa: F401
from .JudgeTools import * # noqa: F403
from .ScheduleBuffSettle import ScheduleBuffSettle # noqa: F401
# TODO:
# buff.ft.label = {"only_CoAttack": 1, "only_技能skill_tag": 1}
# skill.label = {"CoAttack": 1, "accept_buff_Buff名字": 1}
# 按照如上格式，进行Buff的数据库拓展，并且写好构造函数的对应接口。
================================================
FILE: zsim/sim_progress/Buff/buff_class.py
================================================
import ast
import importlib
import json
from functools import lru_cache
from typing import TYPE_CHECKING
import numpy as np
import pandas as pd
from zsim.define import EFFECT_FILE_PATH, EXIST_FILE_PATH, JUDGE_FILE_PATH, config_path
from zsim.sim_progress.Report import report_to_log
from .BuffXLogic._buff_record_base_class import BuffRecordBaseClass as BRBC
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
with open(config_path, "r", encoding="utf-8") as file:
config = json.load(file)
debug = config.get("debug")
with open("./zsim/sim_progress/Buff/buff_config.json", "r", encoding="utf-8") as f:
_buff_load_config = json.load(f)
# 如果禁用缓存，每次都创建新的实例
# 这个index列表里面装的是乘区类型中所有的项目,也是buff效果作用的范围.
# 这个列表中的内容:在Buff效果.csv 中作为索引存在;而在 Event父类中,它们又包含了 info子类的部分内容 和 multiplication子类的全部内容,
# 在文件中,这个list被用在最后的buffchagne()函数中,作为中转字典的keylist存在
# 在重构本程序的过程中,我思考过是否要把这个巨大的indexlist按照乘区划分拆成若干,这意味着Event中的Multi子类或许可以独立出来成为一个单独的父类存在.
# 这样做的好处是:庞大复杂的Multi可以不用蜗居在Event下,结构更加清晰.但是坏处就是,Event和Multi必须1对1实例化,否则容易出现多个动作共用同一份乘区实例的情况,就很容易发生错误NTR(bushi
class Buff:
"""
config字典的键值来自：触发判断.csv
judge_config字典的键值来自：激活判断.csv
"""
@staticmethod
def create_new_from_existing(existing_instance):
"""
已经弃用。
通过复制已有实例的状态来创建新实例
该方法主要用于BuffAddStrategy函数。
"""
new_instance = Buff.__new__(Buff) # 不调用构造函数
new_instance.__dict__ = existing_instance.__dict__.copy() # 复制原实例的属性
return new_instance
def __init__(self, config: pd.Series, judge_config: pd.Series, sim_instance: "Simulator"):
if not hasattr(self, "ft"):
self.ft = self.BuffFeature(config)
self.dy = self.BuffDynamic()
self.sjc = self.BuffSimpleJudgeCondition(judge_config)
self.logic = self.BuffLogic(self)
self.history = self.BuffHistory()
self.effect_dct = self.__lookup_buff_effect(self.ft.index)
self.feature_config = config
self.judge_config = judge_config
else:
self.history.active_times += 1
# 调用特殊的逻辑加载函数
self.buff_config = self.load_config()
self.load_special_judge_config()
self.sim_instance = sim_instance
@staticmethod
def load_config():
"""
加载 Buff 配置文件
"""
return _buff_load_config
def load_special_judge_config(self):
"""
根据Buff的特性选择是否加载特殊的逻辑模块。
动态加载适应于当前Buff实例的复杂逻辑模块。
"""
try:
index = self.ft.index
config = self.buff_config.get(index)
if config:
module_name = config["module"]
class_name = config["class"]
# 动态加载模块
module = importlib.import_module(module_name, package="zsim.sim_progress.Buff")
logic_class = getattr(module, class_name)
self.logic = logic_class(self)
else:
# 默认逻辑
pass
except ModuleNotFoundError:
# 处理模块找不到的情况
print(f"Module for {self.ft.index} not found. Falling back to default logic.")
pass
class BuffFeature:
bf_instance_cache: dict[int, "Buff.BuffFeature"] = {}
max_cache_size = 256
def __new__(cls, config):
cache_key = hash(tuple(sorted(config.items())))
if cache_key in cls.bf_instance_cache:
return cls.bf_instance_cache[cache_key]
instance = super(Buff.BuffFeature, cls).__new__(cls)
if len(cls.bf_instance_cache) >= cls.max_cache_size:
cls.bf_instance_cache.popitem()
cls.bf_instance_cache[cache_key] = instance
return instance
def __init__(self, meta_config: pd.Series):
if not hasattr(self, "name"):
try:
config_dict: dict = dict(meta_config)
except TypeError:
raise TypeError(f"{meta_config} is not a mapping")
self.buff = None
self.simple_judge_logic = config_dict["simple_judge_logic"] # 复杂判断逻辑,
self.simple_start_logic = config_dict[
"simple_start_logic"
] # 复杂开始逻辑,指的是buff的start方式比较特殊，需要代码控制
self.simple_end_logic = config_dict[
"simple_end_logic"
] # 复杂结束逻辑,指的是buff的结束不以常规buff的结束条件为约束的,比如消耗完层数才消失的,比如受击导致持续时间发生跳变的,
self.simple_hit_logic = config_dict["simple_hit_logic"] # 复杂的命中判定逻辑
self.simple_effect_logic = config_dict[
"simple_effect_logic"
] # 复杂的生效逻辑，和simple_start对应
"""
注意，此处的xeffect往往与xjudge进行配合。因为xjudge会导致buff在BuffLoad函数中进入else分支，
如果某buff既有复杂的judge_logic，又有复杂的start/hit/end_logic，
那么后者就应该使用xeffect来写，要不然就会进入simple_start分支而导致代码块无法执行。
"""
self.simple_exit_logic = config_dict["simple_exit_logic"] # 复杂退出逻辑
self.index = config_dict["BuffName"] # buff的英文名,也是buff的索引
self.is_weapon = config_dict["is_weapon"] # buff是否是武器特效
self.is_additional_ability = config_dict[
"is_additional_ability"
] # Buff是否是组队被动Buff
self.refinement = config_dict["refinement"] # 武器特效的精炼等级
self.bufffrom = config_dict[
"from"
] # buff的来源,可以是角色名,也可以是其他,这个字段用来和配置文件比对,比对成功则证明这个buff是可以触发的;
self.description = config_dict[
"description"
] # buff的中文名字,包括一些buff效果的拆分,这里的中文名写的会比较细
self.exist = config_dict["exist"] # buff是否参与了计算,即是否允许被激活
self.durationtype = config_dict[
"durationtype"
] # buff的持续时间类型,如果是True,就是有持续时间的,如果是False,就没有持续时间类型,属于瞬时buff.
self.maxduration = int(config_dict["maxduration"]) # buff最大持续时间
self.maxcount = int(config_dict["maxcount"]) # buff允许被叠加的最大层数
self.step = int(
config_dict["incrementalstep"]
) # buff的自增步长,也可以理解为叠层事件发生时的叠层效率.
self.prejudge = config_dict[
"prejudge"
] # buff的抬手判定类型,True是攻击抬手时会产生判定；False则是不会产生判定
self.endjudge = config_dict[
"endjudge"
] # buff的结束判定类型，True是攻击或动作结束时会产生判定，False则不会产生判定。
self.fresh = config_dict[
"freshtype"
] # buff的刷新类型,True是刷新层数时,刷新时间,False是刷新层数是,不影响时间.
self.alltime = config_dict[
"alltime"
] # buff的永远生效类型,True是无条件永远生效,False是有条件
self.hitincrease = config_dict[
"hitincrease"
] # buff的层数增长类型,True就增长层数 = 命中次数,而False是增长层数为固定值,取决于step数据;
self.cd = int(config_dict["increaseCD"]) # buff的叠层内置CD
self.add_buff_to = config_dict["add_buff_to"] # 记录了buff会被添加给谁?
self.is_debuff = config_dict["is_debuff"] # 记录了这个buff是否是个debuff
self.schedule_judge = config_dict[
"schedule_judge"
] # 记录了这个buff是否需要在schedule阶段处理。
self.backend_acitve = config_dict[
"backend_acitve"
] # 记录了这个buff是否需要在后台才能触发
self.individual_settled = config_dict[
"individual_settled"
] # 记录了这个buff的叠层是否是独立结算
"""
在20241116的更新中，更新了新的buff结算逻辑，针对“层数独立结算”的buff，
在BuffFeature下新增了一个参数：individual_settled
buff在更新或者新建实例时，应该检测该参数是否为True，
如果是True，则应该检索当前DYNAMIC_BUFF_DICT中的buff是否存在，
如果存在，则应该直接更新self.dy.built_in_buff_box。
"""
self.operator = config_dict.get("operator", None)
self.passively_updating = config_dict.get("passively_updating", None)
"""
在20241130的更新中，新增了passively_updating这一参数。
在初始化阶段、生成exist_buff_dict以及一众buff_0时，
会根据对应的添加逻辑，修改这一参数。这一参数可以标志出该buff是否应该由当前角色的行为触发。
这样就可以避免“艾莲的强化E会意外触发苍角核心被动的攻击力buff”
"""
self._beneficiary = None
"""
在20250102的更新中，我们为buff.feature新增了beneficiary这个属性。并且在buff_exist_judge函数中做了对应的初始化逻辑。
该属性是为了标注buff的受益者，至此，operator、beneficiary 与passively_updating三个参数构成了一套相对完整的逻辑。
当operator与beneficiary不同时，passively_updating为True，反之则为False；
但是，以上逻辑暂时还未实装。
编写beneficiary属性的原因：
目前，在Buff循环逻辑中，find_buff_0函数返回的结果只能是equipper的buff_0，这对于大部分buff来说是没有影响的，
但是如果一个Buff加给自己的和加给他人的buff情况不同、而我们有需要去找受益者获取buff_0时，beneficiary属性就派上用场了。
——启发自 Buff 静听嘉音
"""
"""Buff标签"""
self.label: dict[str, list[str] | str] | None = self.__process_label_str(
config_dict
)
"""
标签生效规则：
None: 无标签时，该参数为None
0：所有标签都通过时，才生效，
n(0以外的任意int)：通过n个标签时，就生效。
"""
self.label_effect_rule: int | None = self.__process_label_rule(config_dict)
self.buff0_id = None
__listener_id_str = config_dict.get("listener_id") # 与Buff的伴生的监听器的ID
if __listener_id_str is None or __listener_id_str is np.nan:
self.listener_id = None
else:
self.listener_id = str(__listener_id_str).strip()
@property
def beneficiary(self):
return self._beneficiary
@beneficiary.setter
def beneficiary(self, value):
# if self.index == "Buff-角色-席德-明攻":
# print(11111111, f"席德明攻的受益人变更为{value}，当前buff的操作者是：{self.operator}")
self._beneficiary = value
def __process_label_rule(self, config_dict: dict) -> int | None:
label_rule = config_dict.get("label_effect_rule", 0)
if pd.isna(label_rule) or label_rule is None:
if self.label:
return 0
else:
return None
else:
label_rule = int(label_rule)
assert self.label is not None, (
f"在初始化{self.index}时，label_rule为{label_rule}，但label为None"
)
if label_rule != 0 and label_rule > len(self.label.keys()):
raise ValueError(
f"{self.index}在初始化时填入的label_rule为{label_rule}，大于其label中填入的参数数量！self.ft.label = {self.label}"
)
return label_rule
def __process_label_str(self, config_dict: dict):
"""处理label的初始化！"""
label_str = config_dict.get("label", None)
if label_str is None:
return None
elif isinstance(label_str, str):
if label_str.strip() is None or pd.isna(label_str):
return None
else:
_dict = ast.literal_eval(str(label_str).strip())
return _dict
class BuffDynamic:
def __init__(self):
self.exist = False # buff是否参与了计算,即是否允许被激活
self.active = False # buff当前的激活状态
self.count: int | float = 0 # buff当前层数
self.ready = True # buff的可叠层状态,如果是True,就意味着是内置CD结束了,可以叠层,如果不是True,就不能叠层.
self.startticks = 0 # buff上一次触发的时间(tick)
self.endticks = 0 # buff计划课中,buff的结束时间
self.settle_times = 0 # buff目前已经被结算过的次数
self.buff_from = None # debuff的专用属性，用于记录debuff的来源。
self.built_in_buff_box = [] # 如果self.ft.single_deal是True，则需要创建这个list。
"""
在20241117的更新中，我们新增了built_in_buff_box属性，该属性需要和self.ft.individual_settled进行配合。
如果该参数为True，则在单独结算Buff时，将buff的startticks和endticks以[start，end]的格式存入列表，然后写入这个box。
"""
self.is_changed = False
"""
在20241115的更新中，新增了buff.dy.is_change属性。
该字段记录了当前buff是否已经成功被变更属性。通过该字段就可以区分进入update函数的buff是否真实地改变了数据，
而update_to_buff_0的函数也需要严格根据这个参数的情况来执行。
这能够避免某些本应在hit处更新的buff，于start处执行了update函数，被分入start分支后，
该buff虽然没有改变属性，但是无条件执行了update_to_buff_0，
从而污染了源头数据。导致部分叠层、以及其他属性变更出现问题。
"""
self.effect_available_times = 0 # 剩余的生效次数
def reset_myself(self):
"""更新Buff.dynamic"""
self.active = False
self.count = 0
self.ready = True
self.startticks = 0
self.endticks = 0
self.settle_times = 0
self.built_in_buff_box = []
self.is_changed = False
class BuffLogic:
"""
这是记录所有的复杂逻辑的子类。由于所有的复杂逻辑的调用，都必须从BuffLoadLoop开始。
所以，再复杂的Buff也需要在CSV数据库中输入对应的index以及其他基本属性，使其能够顺利进入BuffLoadLoop。
而真正调用Xlogic模块的地方实际上有两个。Xjudge会在BuffLoadLoop中调用的BuffJudge函数的一个分支中被执行，最终抛出的是布尔值。
第二处则是在Buff.update()函数。为了保证所有的Xlogic都有方式被正确调用，所以，我将复杂的触发逻辑分为了Start、Hit和End三类。
它们会在各自的分支中被调用。
"""
def __init__(self, buff_instance: "Buff"):
self.buff: "Buff" = buff_instance
self.xjudge = None # 判断逻辑
self.xstart = None # 复杂的开始逻辑
self.xhit = None # 复杂的命中更新逻辑
self.xend = None # 结束逻辑
self.xeffect = None # 生效逻辑
self.xexit = None # 退出逻辑
def special_judge_logic(self, **kwargs) -> bool | None:
pass
def special_start_logic(self, **kwargs):
# 这里可以实现特定的开始逻辑
pass
def special_hit_logic(self, **kwargs):
# 这里可以实现特定的命中逻辑
pass
def special_end_logic(self, **kwargs):
# 这里可以实现特定的结束逻辑
pass
def special_effect_logic(self, **kwargs):
pass
def special_exit_logic(self, **kwargs):
pass
class BuffSimpleJudgeCondition:
sjc_instance_cache: dict[int, "Buff.BuffSimpleJudgeCondition"] = {}
max_size = 128
def __new__(cls, judgeconfig):
cache_key = hash(tuple(sorted(judgeconfig.items())))
if cache_key in cls.sjc_instance_cache:
return cls.sjc_instance_cache[cache_key]
instance = object.__new__(cls)
if len(cls.sjc_instance_cache) >= cls.max_size:
cls.sjc_instance_cache.popitem()
cls.sjc_instance_cache[cache_key] = instance
def __init__(self, judgeconfig):
self.buff = None
self.id = judgeconfig["id"]
self.oname = judgeconfig["OfficialName"]
self.sp = judgeconfig["SpConsumption"]
self.spr = judgeconfig["SpRecovery_hit"]
self.fev = judgeconfig["FeverRecovery"]
self.eaa = judgeconfig["ElementAbnormalAccumulation"]
self.st = judgeconfig["SkillType"]
self.tbl = judgeconfig["TriggerBuffLevel"]
self.et = judgeconfig["ElementType"]
self.tc = judgeconfig["TimeCost"]
self.hn = judgeconfig["HitNumber"]
self.da = judgeconfig["DmgRelated_Attributes"]
self.sa = judgeconfig["StunRelated_Attributes"]
class BuffHistory:
def __init__(self):
"""
History是Buff的一个子类,主要记录了buff的触发历史,\n
包括buff的上次结束时间,上次持续时间,激活次数以及结束次数.\n
"""
self.last_end = 0 # buff上一次结束的时间
self.active_times = 0 # buff迄今为止激活过的次数
self.last_duration = 0 # buff上一次的持续时间
self.end_times = 0 # buff结束过的次数
self.real_count = 0 # 莱特组队被动专用的字段，用于记录实层。
self.last_update_tick = 0 # 部分复杂buff需要的上一次更新时间
self.last_update_resource = 0 # 部分复杂buff需要的上一次更新时的资源数量
self.record: "BRBC | None" = None
def reset_myself(self):
"""重置Buff.history"""
self.last_end = 0
self.active_times = 0
self.last_duration = 0
self.end_times = 0
self.real_count = 0
self.last_update_tick = 0
self.last_update_resource = 0
self.record = None
@property
def durtation(self):
if not self.dy.active:
return 0
return self.dy.endticks - self.dy.startticks
def __lookup_buff_effect(self, index: str) -> dict:
"""
根据索引获取buff效果字典。
该方法从json文件中尝试读取所有buff效果数据
找到后，将数据转换为字典并返回。
参数:
- index: buff索引。
返回:
- buff_effect: 包含buff效果的字典。
"""
# 初始化一个空的字典来存储buff效果
# 读取包含所有buff效果的CSV文件
all_buff_js = self.__convert_buff_js(EFFECT_FILE_PATH)
try:
buff = all_buff_js[index]
except KeyError as e:
buff = {}
report_to_log(f"[WARNING] {e}: 索引{index}没有找到，或buff效果json结构错误", level=4)
return buff
@staticmethod
@lru_cache(maxsize=64)
def __convert_buff_js(csv_file):
df = pd.read_csv(csv_file)
width = int(np.ceil(df.shape[1] / 2))
# 初始化结果字典
result = {}
# 遍历 DataFrame 的每一行
for index, row in df.iterrows():
name = row["名称"]
value = {}
# 处理 key-value 对
for i in range(1, width):
try:
key = row[f"key{i}"]
val = row[f"value{i}"]
if pd.notna(key) and pd.notna(val):
value[key] = float(val)
except KeyError:
continue
result[name] = value
return result
def reset_myself(self):
"""Buff的重置函数"""
self.dy.reset_myself()
self.history.reset_myself()
def ready_judge(self, timenow):
"""
用来判断内置CD是否就绪
"""
if not self.dy.ready:
if timenow - self.dy.startticks >= self.ft.cd:
self.dy.ready = True
def is_ready(self, tick: int) -> bool:
"""
用来判断buff是否可以被触发
"""
if self.ft.cd == 0:
return True
else:
if self.dy.startticks == 0:
return True
if tick - self.dy.startticks >= self.ft.cd:
return True
else:
return False
def end(self, timenow, exist_buff_dict: dict):
"""
用来执行buff的结束
"""
buff_0 = exist_buff_dict[self.ft.index]
# buff_0就是buff的源头。位于exsist_buff_dict中。
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
# 在修改buff的状态时，对buff_0进行相同的修改。以保证状态同步。
self.dy.active = False
self.dy.count = 0
self.dy.built_in_buff_box = []
buff_0.dy.active = False
buff_0.dy.count = 0
# 同时，更新buff_0的触发历史记录。
buff_0.history.last_end = timenow
buff_0.history.end_times += 1
buff_0.history.last_duration = max(timenow - self.dy.startticks, 0)
buff_0.dy.built_in_buff_box = []
# 再把当前buff的实例化的history和buff源对齐
self.history.last_end = buff_0.history.last_end
self.history.end_times = buff_0.history.end_times
self.history.last_duration = buff_0.history.last_duration
# report_to_log(
# f'[Buff INFO]:{timenow}:{self.ft.name}第{buff_0.history.end_times}次结束;duration:{buff_0.history.last_duration}', level=3)
def simple_start(self, timenow: int, sub_exist_buff_dict: dict[str, "Buff"], **kwargs):
"""
sub_exist_buff_dict = exist_buff_dict[角色名]
角色名指的是当前的前台角色。
该方法是buff的默认激活方法。它会以最常见的策略激活buff。
让buff具有最基本的start、end两个时间点，以及最基本的层数，
并且更新好Buff的内置CD，最后将所有的信息改动回传给buff0
"""
no_start = kwargs.get("no_start", False)
no_end = kwargs.get("no_end", False)
no_count = kwargs.get("no_count", False)
specified_count = kwargs.get("specified_count", None) # 外部定制层数——层数不独立结算的Buff
_simple_start_buff_0: "Buff" = sub_exist_buff_dict[self.ft.index]
individule_settled_count = kwargs.get("individule_settled_count", 0)
if no_count and any([individule_settled_count, specified_count]):
raise ValueError("在传入no_count参数时，同时传入了其他控制层数的参数。")
if specified_count and self.ft.individual_settled:
raise ValueError("企图使用specified_count参数来控制层数，但该buff不是层数独立结算的。")
if individule_settled_count != 0 and not self.ft.individual_settled:
raise ValueError(
f"对于层数不独立结算的{self.ft.index}，在调用simple_start函数时，不应传入individule_settled_count参数。"
)
if individule_settled_count and specified_count:
raise ValueError("同时传入了individule_settled_count和specified_count参数。")
if individule_settled_count == 0:
individule_settled_count = 1
self.dy.active = True
if not no_start:
self.dy.startticks = timenow
if not no_end:
self.dy.endticks = timenow + self.ft.maxduration
if not no_count:
if self.ft.individual_settled:
for i in range(0, individule_settled_count):
self.dy.built_in_buff_box.append((self.dy.startticks, self.dy.endticks))
while len(self.dy.built_in_buff_box) > self.ft.maxcount:
self.dy.built_in_buff_box.pop(0)
self.dy.count = len(self.dy.built_in_buff_box)
else:
if specified_count:
self.dy.count = specified_count
# print(f"{self.ft.index}的层数被设定为{specified_count}")
else:
self.dy.count = min(
_simple_start_buff_0.dy.count + self.ft.step, self.ft.maxcount
)
self.dy.is_changed = True
self.dy.ready = False
self.update_to_buff_0(_simple_start_buff_0)
# if (
# self.ft.index == "Buff-角色-雨果-1画-决算招式双暴增幅"
# or self.ft.index == "Buff-角色-雨果-2画-决算招式无视防御力"
# ):
# print(f"{self.ft.index}触发了，层数为：{self.dy.count}")
def individual_setteled_update(self, duration, timenow):
"""
各层数单独结算类的buff的更新函数
会首先检查内置的box的容量情况，如果box满了会先进行pop(0)，然后append
最后，更新自身的count
"""
start = timenow
end = timenow + duration
if len(self.dy.built_in_buff_box) == self.ft.maxcount:
if len(self.dy.built_in_buff_box) > self.ft.maxcount:
# 溢出报错
raise ValueError(
f"box的当前大小是{len(self.dy.built_in_buff_box)}，超过了最大容量{self.ft.index}"
)
# 说明此时box的含量已经满了，所以把最老的pop出来。
self.dy.built_in_buff_box.pop(0)
# 不管是否pop，都需要append
self.dy.built_in_buff_box.append((start, end))
self.dy.count = len(self.dy.built_in_buff_box)
self.dy.startticks = start
self.dy.endticks = end
self.dy.active = True
self.dy.ready = False
self.dy.is_changed = True
def update(
self,
char_name: str,
timenow,
timecost,
sub_exist_buff_dict: dict,
sub_mission: str,
):
"""
该函数只负责buff的时间更新。buff该不该进行更新，并不是该函数的负责范围。
往往是在外部函数判断出某个buff需要触发后（通常是新建一个Buff实例）
根据Buff的更新特性（比如fresh、Prejudge等参数）以及对应正在发生的子任务节点，对应的处理buff的dynamic属性。
"""
if self.ft.index not in sub_exist_buff_dict:
raise TypeError(f"{self.ft.index}并不存在于{char_name}的exist_buff_dict中！")
buff_0 = sub_exist_buff_dict[self.ft.index]
if self.ft.alltime:
self.dy.active = True
self.dy.count = 1
self.dy.is_changed = True
self.dy.startticks = timenow
self.update_to_buff_0(buff_0)
return
if buff_0.dy.active:
"""
如果update函数运行时，检测到Buff0已经active，则意味着我们需要更新一个已经被激活的buff。
首先，应该将自身的主要数据与Buff0对齐，这是前提条件。这所有的东西主要是为了叠层服务的。
当然那，不用担心这一步会污染startticks和endticks，因为后面该对这两个东西做出改动的函数，都会改动它们。
不该做出改动的，那自然不需要改，也是符合需求的。
"""
self.download_from_buff_0(buff_0)
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
if buff_0.ft.operator != char_name and char_name != "enemy":
"""
由于传入update函数的sub_exist_buff_dict永远只会来自于buff的实际更新来源（operator），
所以，对于select_character是多个角色的buff，必须在这里进行筛选。
如果查询到buff源的operator 不等于 buff的受益者（也就是这里传入的char_name）
则意味着buff只执行添加，而不执行更新。
只有操作者才有资格更新buff。而在外部，更新、轮询char的顺序，来自于select_character，
该列表是按照操作者作为第一视角的，所以，我们总能保证操作者的更新buff在前，而受益者的被动添加在后。
但是，如果char_name是enemy，则意味着这是要给敌人添加buff。这是单向行为，所以不在这一层屏蔽的范围内。
"""
self.dy.is_changed = True
return
buff_0.ready_judge(timenow)
if not buff_0.dy.ready:
report_to_log(
f"[Buff INFO]:{timenow}:{buff_0.ft.description}内置CD没就绪，并未成功触发",
level=3,
)
return
"""
在执行所有分支之前，自然要判断buff的就绪情况。如果Buff没有就绪，那么一切都是白扯。
因为self自身是刚刚实例化的Buff，肯定是新鲜的，所以，ready的判断要去exist buff dict中的buff0执行，
那里记录着buff的最新情况。
ready检测不通过直接return——cd没转好，所以就算能够触发，也是不会触发的。
"""
if sub_mission == "start":
self.update_cause_start(timenow, timecost, sub_exist_buff_dict, beneficiary=char_name)
elif sub_mission == "end":
if self.ft.endjudge:
self.update_cause_end(timenow, sub_exist_buff_dict, beneficiary=char_name)
elif sub_mission == "hit":
self.update_cause_hit(timenow, sub_exist_buff_dict, timecost, beneficiary=char_name)
def update_to_buff_0(self, buff_0):
"""
该方法往往衔接在buff更新后使用。
由于在buff判定逻辑中，buff的层数、时间的刷新被视为重新激活了一个新的buff，
所以，这个方法需要向exist_buff_dict中的buff源头，也就是buff_0传递一些当前buff的参数
"""
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
buff_0.dy.active = self.dy.active
buff_0.dy.ready = self.dy.ready
buff_0.dy.startticks = self.dy.startticks
buff_0.dy.endticks = self.dy.endticks
buff_0.dy.built_in_buff_box = self.dy.built_in_buff_box
buff_0.history.active_times += 1
if buff_0.ft.individual_settled:
buff_0.dy.count = min(len(self.dy.built_in_buff_box), self.ft.maxcount)
else:
# if buff_0.ft.index == 'Buff-武器-精1啜泣摇篮-全队增伤自增长':
# print(f'buff_0更新前层数：{buff_0.dy.count}， buff自身更新前层数：{self.dy.count}')
buff_0.dy.count = self.dy.count
# if buff_0.ft.index == 'Buff-武器-精1啜泣摇篮-全队增伤自增长':
# print(f'buff_0更新后层数：{buff_0.dy.count}， buff自身更新后层数：{self.dy.count}')
# report_to_log(f'[Buff INFO]:{timenow}:{buff_0.ft.index}第{buff_0.history.active_times}次触发')
def download_from_buff_0(self, buff_0):
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
self.dy.active = buff_0.dy.active
self.dy.ready = buff_0.dy.ready
self.dy.is_changed = buff_0.dy.is_changed
self.dy.startticks = buff_0.dy.startticks
self.dy.endticks = buff_0.dy.endticks
self.dy.built_in_buff_box = buff_0.dy.built_in_buff_box
self.dy.count = buff_0.dy.count
def update_cause_start(self, timenow, timecost, exist_buff_dict: dict, beneficiary: str):
buff_0 = exist_buff_dict[self.ft.index]
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
if not self.ft.simple_start_logic:
# EXAMPLE：Buff触发时，随机获得层数。
assert self.logic.xstart is not None, (
f"{self.ft.index} 的simple_start_logic参数不为True时，其logic.xstart不能为空"
)
self.logic.xstart(beneficiary=beneficiary)
self.update_to_buff_0(buff_0)
return
if self.ft.maxduration == 0: # 瞬时buff
if not self.ft.hitincrease: # 命中不叠层
"""
所有瞬时buff（maxduration=0）中，非命中触发的那部分，
本质上是把瞬时buff看做是一个持续时间为招式持续时间的buff。
所有的“普攻伤害增加”类型的Buff，都是这个逻辑处理的。在出招时候（start）就已经加上了，而在End之后自动结束。
确保该招式内的所有Hit都能享受到加成。
但是，这个函数处理不了在招式内叠层的Buff，在逻辑上绕开了“强化E伤害提高5%，且每命中一次再提高5%”这类buff
就以这个Buff例子为例，这个Buff是Hit事件才会触发的，在Start函数中应该毫无作为，所以必须绕开。
"""
self.dy.active = True
if self.ft.individual_settled:
"""
单独结算的Buff处理逻辑。
"""
# EXAMPLE：发动普攻时，使当前招式伤害增加X%，每层效果独立结算。
self.individual_setteled_update(timecost, timenow)
else:
# EXAMPLE：发动普攻时，使当前招式伤害增加X%，
self.dy.startticks = timenow
self.dy.endticks = timenow + timecost
self.dy.count = min(buff_0.dy.count + self.ft.step, self.ft.maxcount)
self.dy.ready = False
self.dy.is_changed = True
else:
if self.ft.prejudge:
"""
所有具有持续时间的buff中，只有抬手就触发的这一类，会在start标签处更新。
再次强调：但凡是Hit触发的buff，在start标签处都不会做任何改变。
并且，本质上prejudge和hit_increase两个参数在数据库中就是互斥的，
除非，某个Buff在技能抬手就触发，同时还会因为命中而叠层（那也太傻逼了，虽然我觉得这不远了。到时候出问题了记得踢我。）
"""
# FIXME：某个Buff在技能抬手就触发，同时还会因为命中而叠层 的逻辑等待拓展
if self.ft.individual_settled:
# EXAMPLE：发动普攻时，使攻击力提升，每次触发独立结算持续时间。
self.individual_setteled_update(self.ft.maxduration, timenow)
else:
# EXAMPLE：发动普攻时，使攻击力提升，重复触发刷新持续时间
self.dy.active = True
self.dy.startticks = timenow
self.dy.endticks = timenow + self.ft.maxduration
if not self.ft.hitincrease:
self.dy.count = min(buff_0.dy.count + self.ft.step, self.ft.maxcount)
self.dy.ready = False
self.dy.is_changed = True
"""
所有因start标签而更新的buff，它们的底层逻辑往往和Hit更新互斥，
它们的层数计算往往非常直接，就是当前层数 + 步长；
而想要做到所谓的“层数叠加了”，那么当前层数应该从buff_0处获取（这是通用步骤，其他类型的层数更新也是这个流程）
总体层数又被min函数掐死，不用担心移除。
"""
if self.dy.is_changed:
self.update_to_buff_0(buff_0)
# report_to_log(f"[Buff INFO]:{timenow}:{buff_0.ft.index}第{buff_0.history.active_times}次触发", level=3)
def update_cause_end(self, timenow, exist_buff_dict, beneficiary: str):
"""
这个函数一般不会用到，因为不会有动作结束才触发的傻逼buff逻辑。
“艾莲踩了你一脚，你当场不敢发作但是等艾莲转身离开，你触发硬度+3，持续30秒？
还是那句话，因动作结束而触发的Buff就是傻逼，好在这里不需要判断是不是Prejudge了。
"""
buff_0 = exist_buff_dict[self.ft.index]
if self.ft.simple_end_logic:
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
# 至于buff.end()并非在这个环节做出修改，而是应该在主循环开头，遍历DynamicBuffList的时候进行修改。
if self.ft.endjudge:
if self.ft.individual_settled:
self.individual_setteled_update(self.ft.maxduration, timenow)
else:
# EXAMPLE：普攻结束后，伤害增加X%，重复触发刷新持续时间。
self.dy.active = True
self.dy.startticks = timenow
self.dy.endticks = timenow + self.ft.maxduration
self.dy.count = min(buff_0.dy.count + self.ft.step, self.ft.maxcount)
self.dy.ready = False
self.dy.is_changed = True
# report_to_log(f"[Buff INFO]:{timenow}:{buff_0.ft.index}第{buff_0.history.active_times}次触发", level=3)
else:
# EXAMPLE：普攻结束后，随机获得1~10层的攻击力Buff。
assert self.logic.xend is not None, f"{self.ft.index}的buff没有初始化xend方法"
self.logic.xend(beneficiary=beneficiary)
self.dy.is_changed = True
if self.dy.is_changed:
self.update_to_buff_0(buff_0)
def update_cause_hit(self, timenow, exist_buff_dict: dict, timecost, beneficiary: str):
"""
这里是最常用的代码，大部分的buff都是hit标签更新。
当然，第一层就要过hitincrease筛选，但凡不满足的，我hit一万次你也触发不了。
然后就是那些沟槽的 重复触发但不刷新时间的buff（fresh == False）
在处理这些Buff的时候必须忍住不要更新startticks，要不然就全丸辣！
"""
buff_0 = exist_buff_dict[self.ft.index]
if not isinstance(buff_0, Buff):
raise TypeError(f"{buff_0}不是Buff类！")
if not buff_0.dy.active:
# 新触发的buff
if buff_0.ft.maxduration == 0:
endticks = timenow + timecost
else:
endticks = timenow + buff_0.ft.maxduration
else:
# 已经触发了buff
endticks = self.dy.endticks
if not self.ft.simple_hit_logic:
assert self.logic.xhit is not None, f"{self.ft.index}的buff没有初始化xhit方法"
self.logic.xhit(beneficiary=beneficiary)
self.dy.is_changed = True
self.update_to_buff_0(buff_0)
return
if not self.ft.hitincrease:
# EXPLAIN：如果hitincrease是False，则意味着在本函数内完全没有更新的可能，直接return就行。
return
if self.ft.fresh: # 处理可更新的buff（fresh = True）
# EXPLAIN：fresh参数和individual_settled是否等价？不，前者是命中时间完全不修改endticks，而后者则是独立结算机制。
# 在判定逻辑的优先级上，fresh和individual_settled包含关系，如果fresh为FALSE，那么无论层数是否独立结算，都会表现为相同的结果。
# 所以，只有fresh为True的buff，才有被区分是否独立结算的意义。
if self.ft.individual_settled:
# EXAMPLE：普攻命中时，攻击力提高3%，层数之间独立结算。
self.individual_setteled_update(self.ft.maxduration, timenow)
if self.ft.maxduration == 0:
# EXAMPLE：普攻期间命中时，攻击力提高3%，层数之间独立结算。
# 如果maxduration是0，那么endticks是不能变的。要还原回来。
self.dy.endticks = endticks
self.dy.active = True
self.dy.is_changed = True
self.dy.ready = False
else:
# EXAMPLE: 命中可叠层，且持续时间刷新。
# EXAMPLE：所有的具有复杂判断逻辑但是光环类的Debuff会在这里被处理。
self.dy.startticks = timenow
"""
这里还没完呢，startticks虽然更新了，但是endticks要不要更新还得看buff是否是瞬时buff。
瞬时buff到点结束，那就不能改变，只能照抄buff_0，
只有非瞬时buff，才会因hit刷新了持续时间而更新endticks。
"""
self.dy.endticks = (
timenow + self.ft.maxduration if self.ft.maxduration != 0 else endticks
)
self.dy.count = min(buff_0.dy.count + self.ft.step, self.ft.maxcount)
self.dy.active = True
self.dy.is_changed = True
self.dy.ready = False
else:
"""
处理剩下的其他buff逻辑（fresh = False 或瞬时 buff）
这些buff都是startticks不允许更新的，endticks也是如此。
"""
if not self.ft.individual_settled:
# EXAMPLE：强化E持续期间，命中一次叠层一次。
self.dy.count = min(buff_0.dy.count + self.ft.step, self.ft.maxcount)
self.dy.active = True
self.dy.is_changed = True
self.dy.ready = False
# report_to_log(f"[Buff INFO]:{timenow}:{buff_0.ft.index}第{buff_0.history.active_times}次触发", level=3)
if self.dy.is_changed:
self.update_to_buff_0(buff_0)
def __str__(self) -> str:
return f"Buff名: {self.ft.index}→{self.ft.description}"
def __deepcopy__(self, memo):
new_obj = Buff(self.feature_config, self.judge_config, sim_instance=self.sim_instance)
memo[id(self)] = new_obj
return new_obj
def spawn_buff_from_index(index: str, sim_instance: "Simulator"):
"""
注意：本函数基本上是为了Pytest服务的，所以涉及反复打开CSV，基本没有任何性能优化可言
正常的主程序运行不要调用本函数！！！！
"""
def find_row_as_dict(_index: str, csv_path: str):
"""根据index查找对应行并转换为字典"""
try:
df = pd.read_csv(csv_path)
# 查找匹配行（假设索引列名为'BuffName'）
matched = df[df["BuffName"] == _index]
return matched.iloc[0].copy()
except FileNotFoundError:
raise FileNotFoundError(f"CSV文件 {csv_path} 不存在")
trigger_dict = find_row_as_dict(index, EXIST_FILE_PATH)
judge_dict = find_row_as_dict(index, JUDGE_FILE_PATH)
# 创建Buff实例
return Buff(trigger_dict, judge_dict, sim_instance=sim_instance)
================================================
FILE: zsim/sim_progress/Buff/buff_config.json
================================================
{
"Buff-角色-莱特-额外能力-冰火增伤": {
"module": ".BuffXLogic.LighterAdditionalAbility_IceFireBonus",
"class": "LighterExtraSkill_IceFireBonus"
},
"Buff-驱动盘-极地重金属-冲刺与普攻增伤-有条件": {
"module": ".BuffXLogic.PolarMetalFreezeBonus",
"class": "PolarMetalFreezeBonus"
},
"Buff-驱动盘-啄木鸟电音-普攻": {
"module": ".BuffXLogic.WoodpeckerElectroSet4_NA",
"class": "WoodpeckerElectroSet4_NA"
},
"Buff-驱动盘-啄木鸟电音-闪避反击": {
"module": ".BuffXLogic.WoodpeckerElectroSet4_CA",
"class": "WoodpeckerElectroSet4_CA"
},
"Buff-驱动盘-啄木鸟电音-强化特殊技": {
"module": ".BuffXLogic.WoodpeckerElectroSet4_E_EX",
"class": "WoodpeckerElectroSet4_E_EX"
},
"Buff-角色-莱特-核心被动-冲击力提升": {
"module": ".BuffXLogic.LighterUniqueSkillStunBonus",
"class": "LighterUniqueSkillStunBonus"
},
"Buff-角色-莱特-核心被动-失衡时间延长": {
"module": ".BuffXLogic.LighterUniqueSkillStunTimeLimitBonus",
"class": "LighterUniqueSkillStunTimeLimitBonus"
},
"Buff-角色-莱卡恩-额外能力-失衡易伤倍率": {
"module": ".BuffXLogic.LyconAdditionalAbilityStunVulnerability",
"class": "LyconAdditionalAbilityStunVulnerability"
},
"Buff-武器-精1燃狱齿轮-后台能量自动回复": {
"module": ".BuffXLogic.HellfireGearsSpRBonus",
"class": "HellfireGearsSpRBonus"
},
"Buff-武器-精2燃狱齿轮-后台能量自动回复": {
"module": ".BuffXLogic.HellfireGearsSpRBonus",
"class": "HellfireGearsSpRBonus"
},
"Buff-武器-精3燃狱齿轮-后台能量自动回复": {
"module": ".BuffXLogic.HellfireGearsSpRBonus",
"class": "HellfireGearsSpRBonus"
},
"Buff-武器-精4燃狱齿轮-后台能量自动回复": {
"module": ".BuffXLogic.HellfireGearsSpRBonus",
"class": "HellfireGearsSpRBonus"
},
"Buff-武器-精5燃狱齿轮-后台能量自动回复": {
"module": ".BuffXLogic.HellfireGearsSpRBonus",
"class": "HellfireGearsSpRBonus"
},
"Buff-武器-精1玉壶青冰-15层后增伤": {
"module": ".BuffXLogic.IceJadeTeaPotExtraDMGBonus",
"class": "IceJadeTeaPotExtraDMGBonus"
},
"Buff-武器-精2玉壶青冰-15层后增伤": {
"module": ".BuffXLogic.IceJadeTeaPotExtraDMGBonus",
"class": "IceJadeTeaPotExtraDMGBonus"
},
"Buff-武器-精3玉壶青冰-15层后增伤": {
"module": ".BuffXLogic.IceJadeTeaPotExtraDMGBonus",
"class": "IceJadeTeaPotExtraDMGBonus"
},
"Buff-武器-精4玉壶青冰-15层后增伤": {
"module": ".BuffXLogic.IceJadeTeaPotExtraDMGBonus",
"class": "IceJadeTeaPotExtraDMGBonus"
},
"Buff-武器-精5玉壶青冰-15层后增伤": {
"module": ".BuffXLogic.IceJadeTeaPotExtraDMGBonus",
"class": "IceJadeTeaPotExtraDMGBonus"
},
"Buff-异常-霜寒": {
"module": ".BuffXLogic.AnomalyDebuffExitJudge",
"class": "AnomalyDebuffExitJudge"
},
"Buff-异常-畏缩": {
"module": ".BuffXLogic.AnomalyDebuffExitJudge",
"class": "AnomalyDebuffExitJudge"
},
"Buff-异常-烈霜霜寒": {
"module": ".BuffXLogic.AnomalyDebuffExitJudge",
"class": "AnomalyDebuffExitJudge"
},
"Buff-角色-雅-核心被动-冰焰": {
"module": ".BuffXLogic.MiyabiCoreSkill_IceFire",
"class": "MiyabiCoreSkill_IceFire"
},
"Buff-角色-雅-核心被动-霜灼": {
"module": ".BuffXLogic.MiyabiCoreSkill_FrostBurn",
"class": "MiyabiCoreSkill_FrostBurn"
},
"Buff-角色-雅-组队被动-无视冰抗": {
"module": ".BuffXLogic.MiyabiAdditionalAbility_IgnoreIceRes",
"class": "MiyabiAdditionalAbility_IgnoreIceRes"
},
"Buff-音擎-精1霰落星殿-叠层冰伤": {
"module": ".BuffXLogic.HailstormShrineIceBonus",
"class": "HailstormShrineIceBonus"
},
"Buff-音擎-精2霰落星殿-叠层冰伤": {
"module": ".BuffXLogic.HailstormShrineIceBonus",
"class": "HailstormShrineIceBonus"
},
"Buff-音擎-精3霰落星殿-叠层冰伤": {
"module": ".BuffXLogic.HailstormShrineIceBonus",
"class": "HailstormShrineIceBonus"
},
"Buff-音擎-精4霰落星殿-叠层冰伤": {
"module": ".BuffXLogic.HailstormShrineIceBonus",
"class": "HailstormShrineIceBonus"
},
"Buff-音擎-精5霰落星殿-叠层冰伤": {
"module": ".BuffXLogic.HailstormShrineIceBonus",
"class": "HailstormShrineIceBonus"
},
"Buff-驱动盘-折枝剑歌-暴伤": {
"module": ".BuffXLogic.BranchBladeSongCritDamageBonus",
"class": "BranchBladeSongCritDamageBonus"
},
"Buff-驱动盘-折枝剑歌-暴击率": {
"module": ".BuffXLogic.BranchBladeSongCritRateBonus",
"class": "BranchBladeSongCritRateBonus"
},
"Buff-武器-精1贵重骨核-75%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver75Hp",
"class": "PreciousFossilizedCoreStunBonusOver75Hp"
},
"Buff-武器-精2贵重骨核-75%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver75Hp",
"class": "PreciousFossilizedCoreStunBonusOver75Hp"
},
"Buff-武器-精3贵重骨核-75%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver75Hp",
"class": "PreciousFossilizedCoreStunBonusOver75Hp"
},
"Buff-武器-精4贵重骨核-75%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver75Hp",
"class": "PreciousFossilizedCoreStunBonusOver75Hp"
},
"Buff-武器-精5贵重骨核-75%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver75Hp",
"class": "PreciousFossilizedCoreStunBonusOver75Hp"
},
"Buff-武器-精1贵重骨核-50%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver50Hp",
"class": "PreciousFossilizedCoreStunBonusOver50Hp"
},
"Buff-武器-精2贵重骨核-50%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver50Hp",
"class": "PreciousFossilizedCoreStunBonusOver50Hp"
},
"Buff-武器-精3贵重骨核-50%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver50Hp",
"class": "PreciousFossilizedCoreStunBonusOver50Hp"
},
"Buff-武器-精4贵重骨核-50%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver50Hp",
"class": "PreciousFossilizedCoreStunBonusOver50Hp"
},
"Buff-武器-精5贵重骨核-50%以上": {
"module": ".BuffXLogic.PreciousFossilizedCoreStunBonusOver50Hp",
"class": "PreciousFossilizedCoreStunBonusOver50Hp"
},
"Buff-武器-精1人为刀俎": {
"module": ".BuffXLogic.SteamOven",
"class": "SteamOven"
},
"Buff-武器-精2人为刀俎": {
"module": ".BuffXLogic.SteamOven",
"class": "SteamOven"
},
"Buff-武器-精3人为刀俎": {
"module": ".BuffXLogic.SteamOven",
"class": "SteamOven"
},
"Buff-武器-精4人为刀俎": {
"module": ".BuffXLogic.SteamOven",
"class": "SteamOven"
},
"Buff-武器-精5人为刀俎": {
"module": ".BuffXLogic.SteamOven",
"class": "SteamOven"
},
"Buff-角色-苍角-额外能力": {
"module": ".BuffXLogic.SokakuAdditionalAbilityICEBonus",
"class": "SokakuAdditionalAbilityICEBonus"
},
"Buff-角色-苍角-核心被动-1": {
"module": ".BuffXLogic.SokakuUniqueSkillMinorATKBonus",
"class": "SokakuUniqueSkillMinorATKBonus"
},
"Buff-角色-苍角-核心被动-2": {
"module": ".BuffXLogic.SokakuUniqueSkillMajorATKBonus",
"class": "SokakuUniqueSkillMajorATKBonus"
},
"Buff-角色-青衣-核心被动-失衡易伤": {
"module": ".BuffXLogic.QingYiCoreSkillStunDMGBonus",
"class": "QingYiCoreSkillStunDMGBonus"
},
"Buff-角色-青衣-核心被动-额外电压补偿": {
"module": ".BuffXLogic.QingYiCoreSkillExtraStunBonus",
"class": "QingYiCoreSkillExtraStunBonus"
},
"Buff-角色-青衣-额外能力-冲击转攻击": {
"module": ".BuffXLogic.QingYiAdditionalAbilityStunConvertToATK",
"class": "QingYiAdditionalAbilityStunConvertToATK"
},
"Buff-角色-丽娜-核心被动-穿透率": {
"module": ".BuffXLogic.LinaCoreSkillPenRatioBonus",
"class": "LinaCoreSkillPenRatioBonus"
},
"Buff-角色-丽娜-组队被动-增伤": {
"module": ".BuffXLogic.LinaAdditionalSkillEleDMGBonus",
"class": "LinaAdditionalSkillEleDMGBonus"
},
"Buff-驱动盘-自由蓝调-物理": {
"module": ".BuffXLogic.FreedomBlues",
"class": "FreedomBlues"
},
"Buff-驱动盘-自由蓝调-火": {
"module": ".BuffXLogic.FreedomBlues",
"class": "FreedomBlues"
},
"Buff-驱动盘-自由蓝调-冰": {
"module": ".BuffXLogic.FreedomBlues",
"class": "FreedomBlues"
},
"Buff-驱动盘-自由蓝调-电": {
"module": ".BuffXLogic.FreedomBlues",
"class": "FreedomBlues"
},
"Buff-驱动盘-自由蓝调-以太": {
"module": ".BuffXLogic.FreedomBlues",
"class": "FreedomBlues"
},
"Buff-驱动盘-自由蓝调-烈霜": {
"module": ".BuffXLogic.FreedomBlues",
"class": "FreedomBlues"
},
"Buff-驱动盘-静听嘉音-增伤": {
"module": ".BuffXLogic.AstralVoice",
"class": "AstralVoice"
},
"Buff-武器-精1啜泣摇篮-全队增伤自增长": {
"module": ".BuffXLogic.WeepingCradleDMGBonusIncrease",
"class": "WeepingCradleDMGBonusIncrease"
},
"Buff-武器-精1啜泣摇篮-后台回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精2啜泣摇篮-全队增伤自增长": {
"module": ".BuffXLogic.WeepingCradleDMGBonusIncrease",
"class": "WeepingCradleDMGBonusIncrease"
},
"Buff-武器-精2啜泣摇篮-后台回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精3啜泣摇篮-全队增伤自增长": {
"module": ".BuffXLogic.WeepingCradleDMGBonusIncrease",
"class": "WeepingCradleDMGBonusIncrease"
},
"Buff-武器-精3啜泣摇篮-后台回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精4啜泣摇篮-全队增伤自增长": {
"module": ".BuffXLogic.WeepingCradleDMGBonusIncrease",
"class": "WeepingCradleDMGBonusIncrease"
},
"Buff-武器-精4啜泣摇篮-后台回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精5啜泣摇篮-全队增伤自增长": {
"module": ".BuffXLogic.WeepingCradleDMGBonusIncrease",
"class": "WeepingCradleDMGBonusIncrease"
},
"Buff-武器-精5啜泣摇篮-后台回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精1时光切片-回能回喧响": {
"module": ".BuffXLogic.SliceofTimeExtraResources",
"class": "SliceofTimeExtraResources"
},
"Buff-武器-精2时光切片-回能回喧响": {
"module": ".BuffXLogic.SliceofTimeExtraResources",
"class": "SliceofTimeExtraResources"
},
"Buff-武器-精3时光切片-回能回喧响": {
"module": ".BuffXLogic.SliceofTimeExtraResources",
"class": "SliceofTimeExtraResources"
},
"Buff-武器-精4时光切片-回能回喧响": {
"module": ".BuffXLogic.SliceofTimeExtraResources",
"class": "SliceofTimeExtraResources"
},
"Buff-武器-精5时光切片-回能回喧响": {
"module": ".BuffXLogic.SliceofTimeExtraResources",
"class": "SliceofTimeExtraResources"
},
"Buff-武器-精1聚宝箱-回能": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精2聚宝箱-回能": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精3聚宝箱-回能": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精4聚宝箱-回能": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精5聚宝箱-回能": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精1聚宝箱-全队增伤": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精2聚宝箱-全队增伤": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精3聚宝箱-全队增伤": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精4聚宝箱-全队增伤": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精5聚宝箱-全队增伤": {
"module": ".BuffXLogic.TheVault",
"class": "TheVault"
},
"Buff-武器-精1好斗的阿炮-全局攻击力": {
"module": ".BuffXLogic.KaboomTheCannon",
"class": "KaboomTheCannon"
},
"Buff-武器-精2好斗的阿炮-全局攻击力": {
"module": ".BuffXLogic.KaboomTheCannon",
"class": "KaboomTheCannon"
},
"Buff-武器-精3好斗的阿炮-全局攻击力": {
"module": ".BuffXLogic.KaboomTheCannon",
"class": "KaboomTheCannon"
},
"Buff-武器-精4好斗的阿炮-全局攻击力": {
"module": ".BuffXLogic.KaboomTheCannon",
"class": "KaboomTheCannon"
},
"Buff-武器-精5好斗的阿炮-全局攻击力": {
"module": ".BuffXLogic.KaboomTheCannon",
"class": "KaboomTheCannon"
},
"Buff-角色-零号·安比-银星触发器": {
"module": ".BuffXLogic.Soldier0AnbySilverStarTrigger",
"class": "Soldier0AnbySilverStarTrigger"
},
"Buff-角色-零号·安比-核心被动-增伤": {
"module": ".BuffXLogic.Soldier0AnbyCoreSkillDMGBonus",
"class": "Soldier0AnbyCoreSkillDMGBonus"
},
"Buff-角色-零号·安比-核心被动-受暴伤增加": {
"module": ".BuffXLogic.Soldier0AnbyCoreSkillCritDMGBonus",
"class": "Soldier0AnbyCoreSkillCritDMGBonus"
},
"Buff-角色-零号·安比-组队被动-全队对银星目标增伤": {
"module": ".BuffXLogic.Soldier0AnbyAdditionalSkillDMGBonus",
"class": "Soldier0AnbyAdditionalSkillDMGBonus"
},
"Buff-角色-零号·安比-4画-无视电抗": {
"module": ".BuffXLogic.Soldier0AnbyCinema4EleResReduce",
"class": "Soldier0AnbyCinema4EleResReduce"
},
"Buff-武器-精1牺牲洁纯-触发暴伤": {
"module": ".BuffXLogic.SeveredInnocenceCritDMGBonus",
"class": "SeveredInnocenceCritDMGBonus"
},
"Buff-武器-精2牺牲洁纯-触发暴伤": {
"module": ".BuffXLogic.SeveredInnocenceCritDMGBonus",
"class": "SeveredInnocenceCritDMGBonus"
},
"Buff-武器-精3牺牲洁纯-触发暴伤": {
"module": ".BuffXLogic.SeveredInnocenceCritDMGBonus",
"class": "SeveredInnocenceCritDMGBonus"
},
"Buff-武器-精4牺牲洁纯-触发暴伤": {
"module": ".BuffXLogic.SeveredInnocenceCritDMGBonus",
"class": "SeveredInnocenceCritDMGBonus"
},
"Buff-武器-精5牺牲洁纯-触发暴伤": {
"module": ".BuffXLogic.SeveredInnocenceCritDMGBonus",
"class": "SeveredInnocenceCritDMGBonus"
},
"Buff-武器-精1牺牲洁纯-满层电伤": {
"module": ".BuffXLogic.SeveredInnocencELEDMGBonus",
"class": "SeveredInnocencELEDMGBonus"
},
"Buff-武器-精2牺牲洁纯-满层电伤": {
"module": ".BuffXLogic.SeveredInnocencELEDMGBonus",
"class": "SeveredInnocencELEDMGBonus"
},
"Buff-武器-精3牺牲洁纯-满层电伤": {
"module": ".BuffXLogic.SeveredInnocencELEDMGBonus",
"class": "SeveredInnocencELEDMGBonus"
},
"Buff-武器-精4牺牲洁纯-满层电伤": {
"module": ".BuffXLogic.SeveredInnocencELEDMGBonus",
"class": "SeveredInnocencELEDMGBonus"
},
"Buff-武器-精5牺牲洁纯-满层电伤": {
"module": ".BuffXLogic.SeveredInnocencELEDMGBonus",
"class": "SeveredInnocencELEDMGBonus"
},
"Buff-驱动盘-如影相随-四件套": {
"module": ".BuffXLogic.ShadowHarmony4",
"class": "ShadowHarmony4"
},
"Buff-角色-扳机-协同攻击-触发器": {
"module": ".BuffXLogic.TriggerAfterShockTrigger",
"class": "TriggerAfterShockTrigger"
},
"Buff-角色-扳机-核心被动-失衡易伤": {
"module": ".BuffXLogic.TriggerCoreSkillStunDMGBonus",
"class": "TriggerCoreSkillStunDMGBonus"
},
"Buff-角色-扳机-额外能力-追加攻击失衡值提升": {
"module": ".BuffXLogic.TriggerAdditionalAbilityStunBonus",
"class": "TriggerAdditionalAbilityStunBonus"
},
"Buff-角色-扳机-1画-失衡易伤提升": {
"module": ".BuffXLogic.TriggerCoreSkillStunDMGBonus",
"class": "TriggerCoreSkillStunDMGBonus"
},
"Buff-武器-精1索魂影眸-减防": {
"module": ".BuffXLogic.SpectralGazeDefReduce",
"class": "SpectralGazeDefReduce"
},
"Buff-武器-精2索魂影眸-减防": {
"module": ".BuffXLogic.SpectralGazeDefReduce",
"class": "SpectralGazeDefReduce"
},
"Buff-武器-精3索魂影眸-减防": {
"module": ".BuffXLogic.SpectralGazeDefReduce",
"class": "SpectralGazeDefReduce"
},
"Buff-武器-精4索魂影眸-减防": {
"module": ".BuffXLogic.SpectralGazeDefReduce",
"class": "SpectralGazeDefReduce"
},
"Buff-武器-精5索魂影眸-减防": {
"module": ".BuffXLogic.SpectralGazeDefReduce",
"class": "SpectralGazeDefReduce"
},
"Buff-武器-精1索魂影眸-魂锁": {
"module": ".BuffXLogic.SpectralGazeSpiritLock",
"class": "SpectralGazeSpiritLock"
},
"Buff-武器-精2索魂影眸-魂锁": {
"module": ".BuffXLogic.SpectralGazeSpiritLock",
"class": "SpectralGazeSpiritLock"
},
"Buff-武器-精3索魂影眸-魂锁": {
"module": ".BuffXLogic.SpectralGazeSpiritLock",
"class": "SpectralGazeSpiritLock"
},
"Buff-武器-精4索魂影眸-魂锁": {
"module": ".BuffXLogic.SpectralGazeSpiritLock",
"class": "SpectralGazeSpiritLock"
},
"Buff-武器-精5索魂影眸-魂锁": {
"module": ".BuffXLogic.SpectralGazeSpiritLock",
"class": "SpectralGazeSpiritLock"
},
"Buff-武器-精1索魂影眸-冲击力": {
"module": ".BuffXLogic.SpectralGazeImpactBonus",
"class": "SpectralGazeImpactBonus"
},
"Buff-武器-精2索魂影眸-冲击力": {
"module": ".BuffXLogic.SpectralGazeImpactBonus",
"class": "SpectralGazeImpactBonus"
},
"Buff-武器-精3索魂影眸-冲击力": {
"module": ".BuffXLogic.SpectralGazeImpactBonus",
"class": "SpectralGazeImpactBonus"
},
"Buff-武器-精4索魂影眸-冲击力": {
"module": ".BuffXLogic.SpectralGazeImpactBonus",
"class": "SpectralGazeImpactBonus"
},
"Buff-武器-精5索魂影眸-冲击力": {
"module": ".BuffXLogic.SpectralGazeImpactBonus",
"class": "SpectralGazeImpactBonus"
},
"Buff-角色-柳-架势-上弦": {
"module": ".BuffXLogic.YanagiStanceJougen",
"class": "YanagiStanceJougen"
},
"Buff-角色-柳-架势-下弦": {
"module": ".BuffXLogic.YanagiStanceKagen",
"class": "YanagiStanceKagen"
},
"Buff-角色-柳-极性紊乱触发器": {
"module": ".BuffXLogic.YanagiPolarityDisorderTrigger",
"class": "YanagiPolarityDisorderTrigger"
},
"Buff-角色-简-狂热状态触发器": {
"module": ".BuffXLogic.JanePassionStateTrigger",
"class": "JanePassionStateTrigger"
},
"Buff-角色-简-狂热-物理积蓄效率提升": {
"module": ".BuffXLogic.JanePassionStatePhyBuildupBonus",
"class": "JanePassionStatePhyBuildupBonus"
},
"Buff-角色-简-狂热-额外精通转攻击力": {
"module": ".BuffXLogic.JanePassionStateAPTransToATK",
"class": "JanePassionStateAPTransToATK"
},
"Buff-角色-简-核心被动-啮咬-强击暴击率提升": {
"module": ".BuffXLogic.JaneCoreSkillStrikeCritRateBonus",
"class": "JaneCoreSkillStrikeCritRateBonus"
},
"Buff-角色-简-核心被动-啮咬-强击暴击伤害提升": {
"module": ".BuffXLogic.JaneCoreSkillStrikeCritDmgBonus",
"class": "JaneCoreSkillStrikeCritDmgBonus"
},
"Buff-角色-简-额外能力-物理异常积蓄效率额外提升": {
"module": ".BuffXLogic.JaneAdditionalAbilityPhyBuildupBonus",
"class": "JaneAdditionalAbilityPhyBuildupBonus"
},
"Buff-角色-简-1画-狂热物理异常积蓄效率额外提升": {
"module": ".BuffXLogic.JanePassionStatePhyBuildupBonus",
"class": "JanePassionStatePhyBuildupBonus"
},
"Buff-角色-简-1画-精通转增伤": {
"module": ".BuffXLogic.JaneCinema1APTransToDmgBonus",
"class": "JaneCinema1APTransToDmgBonus"
},
"Buff-角色-简-2画-啮咬-强击无视防御与暴击伤害提升" : {
"module": ".BuffXLogic.JaneCoreSkillStrikeCritDmgBonus",
"class": "JaneCoreSkillStrikeCritDmgBonus"
},
"Buff-角色-简-2画-啮咬-攻击无视防御" : {
"module": ".BuffXLogic.JaneCoreSkillStrikeCritDmgBonus",
"class": "JaneCoreSkillStrikeCritDmgBonus"
},
"Buff-角色-柳-1画-精通增幅": {
"module": ".BuffXLogic.YangiCinema1ApBonus",
"class": "YangiCinema1ApBonus"
},
"Buff-角色-柳-6画-特殊技伤害提升": {
"module": ".BuffXLogic.YanagiCinema6EXDmgBonus",
"class": "YanagiCinema6EXDmgBonus"
},
"Buff-角色-薇薇安-协同攻击触发器": {
"module": ".BuffXLogic.VivianCoattackTrigger",
"class": "VivianCoattackTrigger"
},
"Buff-角色-薇薇安-羽毛结算触发器": {
"module": ".BuffXLogic.VivianFeatherTrigger",
"class": "VivianFeatherTrigger"
},
"Buff-角色-薇薇安-核心被动触发器": {
"module": ".BuffXLogic.VivianCorePassiveTrigger",
"class": "VivianCorePassiveTrigger"
},
"Buff-角色-薇薇安-预言触发器": {
"module": ".BuffXLogic.VivianDotTrigger",
"class": "VivianDotTrigger"
},
"Buff-角色-薇薇安-额外能力-协同攻击触发器": {
"module": ".BuffXLogic.VivianAdditionalAbilityCoAttackTrigger",
"class": "VivianAdditionalAbilityCoAttackTrigger"
},
"Buff-角色-薇薇安-1画-全属性异常和紊乱伤害提升": {
"module": ".BuffXLogic.VivianCinema1Debuff",
"class": "VivianCinema1Debuff"
},
"Buff-角色-薇薇安-6画-触发器": {
"module": ".BuffXLogic.VivianCinema6Trigger",
"class": "VivianCinema6Trigger"
},
"Buff-驱动盘-法厄同之歌-四件套-以太伤害提高": {
"module": ".BuffXLogic.PhaethonsMelody",
"class": "PhaethonsMelody"
},
"Buff-武器-精1飞鸟星梦-精通增幅": {
"module": ".BuffXLogic.FlightOfFancy",
"class": "FlightOfFancy"
},
"Buff-武器-精2飞鸟星梦-精通增幅": {
"module": ".BuffXLogic.FlightOfFancy",
"class": "FlightOfFancy"
},
"Buff-武器-精3飞鸟星梦-精通增幅": {
"module": ".BuffXLogic.FlightOfFancy",
"class": "FlightOfFancy"
},
"Buff-武器-精4飞鸟星梦-精通增幅": {
"module": ".BuffXLogic.FlightOfFancy",
"class": "FlightOfFancy"
},
"Buff-武器-精5飞鸟星梦-精通增幅": {
"module": ".BuffXLogic.FlightOfFancy",
"class": "FlightOfFancy"
},
"Buff-武器-精1时流贤者-精通提升": {
"module": ".BuffXLogic.TimeweaverApBonus",
"class": "TimeweaverApBonus"
},
"Buff-武器-精2时流贤者-精通提升": {
"module": ".BuffXLogic.TimeweaverApBonus",
"class": "TimeweaverApBonus"
},
"Buff-武器-精3时流贤者-精通提升": {
"module": ".BuffXLogic.TimeweaverApBonus",
"class": "TimeweaverApBonus"
},
"Buff-武器-精4时流贤者-精通提升": {
"module": ".BuffXLogic.TimeweaverApBonus",
"class": "TimeweaverApBonus"
},
"Buff-武器-精5时流贤者-精通提升": {
"module": ".BuffXLogic.TimeweaverApBonus",
"class": "TimeweaverApBonus"
},
"Buff-武器-精1时流贤者-装备者紊乱伤害提升": {
"module": ".BuffXLogic.TimeweaverDisorderDmgMul",
"class": "TimeweaverDisorderDmgMul"
},
"Buff-武器-精2时流贤者-装备者紊乱伤害提升": {
"module": ".BuffXLogic.TimeweaverDisorderDmgMul",
"class": "TimeweaverDisorderDmgMul"
},
"Buff-武器-精3时流贤者-装备者紊乱伤害提升": {
"module": ".BuffXLogic.TimeweaverDisorderDmgMul",
"class": "TimeweaverDisorderDmgMul"
},
"Buff-武器-精4时流贤者-装备者紊乱伤害提升": {
"module": ".BuffXLogic.TimeweaverDisorderDmgMul",
"class": "TimeweaverDisorderDmgMul"
},
"Buff-武器-精5时流贤者-装备者紊乱伤害提升": {
"module": ".BuffXLogic.TimeweaverDisorderDmgMul",
"class": "TimeweaverDisorderDmgMul"
},
"Buff-武器-精1淬锋钳刺-猎意": {
"module": ".BuffXLogic.SharpenedStingerPhyDmgBonus",
"class": "SharpenedStingerPhyDmgBonus"
},
"Buff-武器-精2淬锋钳刺-猎意": {
"module": ".BuffXLogic.SharpenedStingerPhyDmgBonus",
"class": "SharpenedStingerPhyDmgBonus"
},
"Buff-武器-精3淬锋钳刺-猎意": {
"module": ".BuffXLogic.SharpenedStingerPhyDmgBonus",
"class": "SharpenedStingerPhyDmgBonus"
},
"Buff-武器-精4淬锋钳刺-猎意": {
"module": ".BuffXLogic.SharpenedStingerPhyDmgBonus",
"class": "SharpenedStingerPhyDmgBonus"
},
"Buff-武器-精5淬锋钳刺-猎意": {
"module": ".BuffXLogic.SharpenedStingerPhyDmgBonus",
"class": "SharpenedStingerPhyDmgBonus"
},
"Buff-武器-精1淬锋钳刺-属性异常积蓄效率提升" : {
"module": ".BuffXLogic.SharpenedStingerAnomalyBuildupBonus",
"class": "SharpenedStingerAnomalyBuildupBonus"
},
"Buff-武器-精2淬锋钳刺-属性异常积蓄效率提升" : {
"module": ".BuffXLogic.SharpenedStingerAnomalyBuildupBonus",
"class": "SharpenedStingerAnomalyBuildupBonus"
},
"Buff-武器-精3淬锋钳刺-属性异常积蓄效率提升" : {
"module": ".BuffXLogic.SharpenedStingerAnomalyBuildupBonus",
"class": "SharpenedStingerAnomalyBuildupBonus"
},
"Buff-武器-精4淬锋钳刺-属性异常积蓄效率提升" : {
"module": ".BuffXLogic.SharpenedStingerAnomalyBuildupBonus",
"class": "SharpenedStingerAnomalyBuildupBonus"
},
"Buff-武器-精5淬锋钳刺-属性异常积蓄效率提升" : {
"module": ".BuffXLogic.SharpenedStingerAnomalyBuildupBonus",
"class": "SharpenedStingerAnomalyBuildupBonus"
},
"Buff-角色-耀佳音-咏叹华彩": {
"module": ".BuffXLogic.AstraYaoIdyllicCadenza",
"class": "AstraYaoIdyllicCadenza"
},
"Buff-角色-耀佳音-核心被动-攻击力": {
"module": ".BuffXLogic.AstraYaoCorePassiveAtkBonus",
"class": "AstraYaoCorePassiveAtkBonus"
},
"Buff-角色-耀佳音-快支管理器-触发器": {
"module": ".BuffXLogic.AstraYaoQuickAssistManagerTrigger",
"class": "AstraYaoQuickAssistManagerTrigger"
},
"Buff-角色-耀佳音-震音管理器-触发器": {
"module": ".BuffXLogic.AstraYaoChordManagerTrigger",
"class": "AstraYaoChordManagerTrigger"
},
"Buff-武器-精1玲珑妆匣-回能": {
"module": ".BuffXLogic.ElegantVanitySpRecover",
"class": "ElegantVanitySpRecover"
},
"Buff-武器-精2玲珑妆匣-回能": {
"module": ".BuffXLogic.ElegantVanitySpRecover",
"class": "ElegantVanitySpRecover"
},
"Buff-武器-精3玲珑妆匣-回能": {
"module": ".BuffXLogic.ElegantVanitySpRecover",
"class": "ElegantVanitySpRecover"
},
"Buff-武器-精4玲珑妆匣-回能": {
"module": ".BuffXLogic.ElegantVanitySpRecover",
"class": "ElegantVanitySpRecover"
},
"Buff-武器-精5玲珑妆匣-回能": {
"module": ".BuffXLogic.ElegantVanitySpRecover",
"class": "ElegantVanitySpRecover"
},
"Buff-武器-精1玲珑妆匣-全队增伤": {
"module": ".BuffXLogic.ElegantVanityDmgBonus",
"class": "ElegantVanityDmgBonus"
},
"Buff-武器-精2玲珑妆匣-全队增伤": {
"module": ".BuffXLogic.ElegantVanityDmgBonus",
"class": "ElegantVanityDmgBonus"
},
"Buff-武器-精3玲珑妆匣-全队增伤": {
"module": ".BuffXLogic.ElegantVanityDmgBonus",
"class": "ElegantVanityDmgBonus"
},
"Buff-武器-精4玲珑妆匣-全队增伤": {
"module": ".BuffXLogic.ElegantVanityDmgBonus",
"class": "ElegantVanityDmgBonus"
},
"Buff-武器-精5玲珑妆匣-全队增伤": {
"module": ".BuffXLogic.ElegantVanityDmgBonus",
"class": "ElegantVanityDmgBonus"
},
"Buff-武器-精1灼心摇壶-回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精2灼心摇壶-回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精3灼心摇壶-回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精4灼心摇壶-回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精5灼心摇壶-回能": {
"module": ".BuffXLogic.BackendJudge",
"class": "BackendJudge"
},
"Buff-武器-精1灼心摇壶-增伤": {
"module": ".BuffXLogic.FlamemakerShakerDmgBonus",
"class": "FlamemakerShakerDmgBonus"
},
"Buff-武器-精2灼心摇壶-增伤": {
"module": ".BuffXLogic.FlamemakerShakerDmgBonus",
"class": "FlamemakerShakerDmgBonus"
},
"Buff-武器-精3灼心摇壶-增伤": {
"module": ".BuffXLogic.FlamemakerShakerDmgBonus",
"class": "FlamemakerShakerDmgBonus"
},
"Buff-武器-精4灼心摇壶-增伤": {
"module": ".BuffXLogic.FlamemakerShakerDmgBonus",
"class": "FlamemakerShakerDmgBonus"
},
"Buff-武器-精5灼心摇壶-增伤": {
"module": ".BuffXLogic.FlamemakerShakerDmgBonus",
"class": "FlamemakerShakerDmgBonus"
},
"Buff-武器-精1灼心摇壶-精通": {
"module": ".BuffXLogic.FlamemakerShakerApBonus",
"class": "FlamemakerShakerApBonus"
},
"Buff-武器-精2灼心摇壶-精通": {
"module": ".BuffXLogic.FlamemakerShakerApBonus",
"class": "FlamemakerShakerApBonus"
},
"Buff-武器-精3灼心摇壶-精通": {
"module": ".BuffXLogic.FlamemakerShakerApBonus",
"class": "FlamemakerShakerApBonus"
},
"Buff-武器-精4灼心摇壶-精通": {
"module": ".BuffXLogic.FlamemakerShakerApBonus",
"class": "FlamemakerShakerApBonus"
},
"Buff-武器-精5灼心摇壶-精通": {
"module": ".BuffXLogic.FlamemakerShakerApBonus",
"class": "FlamemakerShakerApBonus"
},
"Buff-武器-精1雨林饕客-局内攻击力": {
"module": ".BuffXLogic.RainforestGourmetATKBonus",
"class": "RainforestGourmetATKBonus"
},
"Buff-武器-精2雨林饕客-局内攻击力": {
"module": ".BuffXLogic.RainforestGourmetATKBonus",
"class": "RainforestGourmetATKBonus"
},
"Buff-武器-精3雨林饕客-局内攻击力": {
"module": ".BuffXLogic.RainforestGourmetATKBonus",
"class": "RainforestGourmetATKBonus"
},
"Buff-武器-精4雨林饕客-局内攻击力": {
"module": ".BuffXLogic.RainforestGourmetATKBonus",
"class": "RainforestGourmetATKBonus"
},
"Buff-武器-精5雨林饕客-局内攻击力": {
"module": ".BuffXLogic.RainforestGourmetATKBonus",
"class": "RainforestGourmetATKBonus"
},
"Buff-武器-精1双生泣星-精通增幅": {
"module": ".BuffXLogic.WeepingGeminiApBonus",
"class": "WeepingGeminiApBonus"
},
"Buff-武器-精2双生泣星-精通增幅": {
"module": ".BuffXLogic.WeepingGeminiApBonus",
"class": "WeepingGeminiApBonus"
},
"Buff-武器-精3双生泣星-精通增幅": {
"module": ".BuffXLogic.WeepingGeminiApBonus",
"class": "WeepingGeminiApBonus"
},
"Buff-武器-精4双生泣星-精通增幅": {
"module": ".BuffXLogic.WeepingGeminiApBonus",
"class": "WeepingGeminiApBonus"
},
"Buff-武器-精5双生泣星-精通增幅": {
"module": ".BuffXLogic.WeepingGeminiApBonus",
"class": "WeepingGeminiApBonus"
},
"Buff-武器-精1触电唇彩-攻击力与增伤": {
"module": ".BuffXLogic.ElectroLipGlossAtkAndDmgBonus",
"class": "ElectroLipGlossAtkAndDmgBonus"
},
"Buff-武器-精2触电唇彩-攻击力与增伤": {
"module": ".BuffXLogic.ElectroLipGlossAtkAndDmgBonus",
"class": "ElectroLipGlossAtkAndDmgBonus"
},
"Buff-武器-精3触电唇彩-攻击力与增伤": {
"module": ".BuffXLogic.ElectroLipGlossAtkAndDmgBonus",
"class": "ElectroLipGlossAtkAndDmgBonus"
},
"Buff-武器-精4触电唇彩-攻击力与增伤": {
"module": ".BuffXLogic.ElectroLipGlossAtkAndDmgBonus",
"class": "ElectroLipGlossAtkAndDmgBonus"
},
"Buff-武器-精5触电唇彩-攻击力与增伤": {
"module": ".BuffXLogic.ElectroLipGlossAtkAndDmgBonus",
"class": "ElectroLipGlossAtkAndDmgBonus"
},
"Buff-武器-精1轰鸣座驾-触发器": {
"module": ".BuffXLogic.RoaringRideBuffTrigger",
"class": "RoaringRideBuffTrigger"
},
"Buff-武器-精2轰鸣座驾-触发器": {
"module": ".BuffXLogic.RoaringRideBuffTrigger",
"class": "RoaringRideBuffTrigger"
},
"Buff-武器-精3轰鸣座驾-触发器": {
"module": ".BuffXLogic.RoaringRideBuffTrigger",
"class": "RoaringRideBuffTrigger"
},
"Buff-武器-精4轰鸣座驾-触发器": {
"module": ".BuffXLogic.RoaringRideBuffTrigger",
"class": "RoaringRideBuffTrigger"
},
"Buff-武器-精5轰鸣座驾-触发器": {
"module": ".BuffXLogic.RoaringRideBuffTrigger",
"class": "RoaringRideBuffTrigger"
},
"Buff-武器-精1「电磁暴」-壹式-异常掌控": {
"module": ".BuffXLogic.MagneticStormAlphaAMBonus",
"class": "MagneticStormAlphaAMBonus"
},
"Buff-武器-精2「电磁暴」-壹式-异常掌控": {
"module": ".BuffXLogic.MagneticStormAlphaAMBonus",
"class": "MagneticStormAlphaAMBonus"
},
"Buff-武器-精3「电磁暴」-壹式-异常掌控": {
"module": ".BuffXLogic.MagneticStormAlphaAMBonus",
"class": "MagneticStormAlphaAMBonus"
},
"Buff-武器-精4「电磁暴」-壹式-异常掌控": {
"module": ".BuffXLogic.MagneticStormAlphaAMBonus",
"class": "MagneticStormAlphaAMBonus"
},
"Buff-武器-精5「电磁暴」-壹式-异常掌控": {
"module": ".BuffXLogic.MagneticStormAlphaAMBonus",
"class": "MagneticStormAlphaAMBonus"
},
"Buff-武器-精2「电磁暴」-贰式-异常精通": {
"module": ".BuffXLogic.MagneticStormBravoApBonus",
"class": "MagneticStormBravoApBonus"
},
"Buff-武器-精3「电磁暴」-贰式-异常精通": {
"module": ".BuffXLogic.MagneticStormBravoApBonus",
"class": "MagneticStormBravoApBonus"
},
"Buff-武器-精4「电磁暴」-贰式-异常精通": {
"module": ".BuffXLogic.MagneticStormBravoApBonus",
"class": "MagneticStormBravoApBonus"
},
"Buff-武器-精5「电磁暴」-贰式-异常精通": {
"module": ".BuffXLogic.MagneticStormBravoApBonus",
"class": "MagneticStormBravoApBonus"
},
"Buff-武器-精1「电磁暴」-叁式-回能": {
"module": ".BuffXLogic.MagneticStormCharlieSpRecover",
"class": "MagneticStormCharlieSpRecover"
},
"Buff-武器-精2「电磁暴」-叁式-回能": {
"module": ".BuffXLogic.MagneticStormCharlieSpRecover",
"class": "MagneticStormCharlieSpRecover"
},
"Buff-武器-精3「电磁暴」-叁式-回能": {
"module": ".BuffXLogic.MagneticStormCharlieSpRecover",
"class": "MagneticStormCharlieSpRecover"
},
"Buff-武器-精4「电磁暴」-叁式-回能": {
"module": ".BuffXLogic.MagneticStormCharlieSpRecover",
"class": "MagneticStormCharlieSpRecover"
},
"Buff-武器-精5「电磁暴」-叁式-回能": {
"module": ".BuffXLogic.MagneticStormCharlieSpRecover",
"class": "MagneticStormCharlieSpRecover"
},
"Buff-角色-雨果-核心被动-单击破攻击力": {
"module": ".BuffXLogic.HugoCorePassiveSingleStunAtkBonus",
"class": "HugoCorePassiveSingleStunAtkBonus"
},
"Buff-角色-雨果-核心被动-双击破攻击力": {
"module": ".BuffXLogic.HugoCorePassiveDoubleStunAtkBonus",
"class": "HugoCorePassiveDoubleStunAtkBonus"
},
"Buff-角色-雨果-决算触发器": {
"module": ".BuffXLogic.HugoCorePassiveTotalizeTrigger",
"class": "HugoCorePassiveTotalizeTrigger"
},
"Buff-角色-雨果-核心被动-强化E失衡值提升": {
"module": ".BuffXLogic.HugoCorePassiveEXStunBonus",
"class": "HugoCorePassiveEXStunBonus"
},
"Buff-角色-雨果-额外能力-连携技对普通敌人伤害提升": {
"module": ".BuffXLogic.HugoAdditionalAbilityExtraQTEDmgBonus",
"class": "HugoAdditionalAbilityExtraQTEDmgBonus"
},
"Buff-驱动盘-激素朋克-全局攻击力": {
"module": ".BuffXLogic.HormonePunkAtkBonus",
"class": "HormonePunkAtkBonus"
},
"Buff-武器-精1防暴者Ⅵ型-普攻增伤": {
"module": ".BuffXLogic.RiotSuppressorMarkVI",
"class": "RiotSuppressorMarkVI"
},
"Buff-武器-精2防暴者Ⅵ型-普攻增伤": {
"module": ".BuffXLogic.RiotSuppressorMarkVI",
"class": "RiotSuppressorMarkVI"
},
"Buff-武器-精3防暴者Ⅵ型-普攻增伤": {
"module": ".BuffXLogic.RiotSuppressorMarkVI",
"class": "RiotSuppressorMarkVI"
},
"Buff-武器-精4防暴者Ⅵ型-普攻增伤": {
"module": ".BuffXLogic.RiotSuppressorMarkVI",
"class": "RiotSuppressorMarkVI"
},
"Buff-武器-精5防暴者Ⅵ型-普攻增伤": {
"module": ".BuffXLogic.RiotSuppressorMarkVI",
"class": "RiotSuppressorMarkVI"
},
"Buff-武器-精1残心青囊-条件暴击率": {
"module": ".BuffXLogic.ZanshinHerbCase",
"class": "ZanshinHerbCase"
},
"Buff-武器-精2残心青囊-条件暴击率": {
"module": ".BuffXLogic.ZanshinHerbCase",
"class": "ZanshinHerbCase"
},
"Buff-武器-精3残心青囊-条件暴击率": {
"module": ".BuffXLogic.ZanshinHerbCase",
"class": "ZanshinHerbCase"
},
"Buff-武器-精4残心青囊-条件暴击率": {
"module": ".BuffXLogic.ZanshinHerbCase",
"class": "ZanshinHerbCase"
},
"Buff-武器-精5残心青囊-条件暴击率": {
"module": ".BuffXLogic.ZanshinHerbCase",
"class": "ZanshinHerbCase"
},
"Buff-武器-精1心弦夜响-无视火抗": {
"module": ".BuffXLogic.HeartstringNocturne",
"class": "HeartstringNocturne"
},
"Buff-武器-精2心弦夜响-无视火抗": {
"module": ".BuffXLogic.HeartstringNocturne",
"class": "HeartstringNocturne"
},
"Buff-武器-精3心弦夜响-无视火抗": {
"module": ".BuffXLogic.HeartstringNocturne",
"class": "HeartstringNocturne"
},
"Buff-武器-精4心弦夜响-无视火抗": {
"module": ".BuffXLogic.HeartstringNocturne",
"class": "HeartstringNocturne"
},
"Buff-武器-精5心弦夜响-无视火抗": {
"module": ".BuffXLogic.HeartstringNocturne",
"class": "HeartstringNocturne"
},
"Buff-武器-精1街头巨星-终结技增伤": {
"module": ".BuffXLogic.StreetSuperstar",
"class": "StreetSuperstar"
},
"Buff-武器-精2街头巨星-终结技增伤": {
"module": ".BuffXLogic.StreetSuperstar",
"class": "StreetSuperstar"
},
"Buff-武器-精3街头巨星-终结技增伤": {
"module": ".BuffXLogic.StreetSuperstar",
"class": "StreetSuperstar"
},
"Buff-武器-精4街头巨星-终结技增伤": {
"module": ".BuffXLogic.StreetSuperstar",
"class": "StreetSuperstar"
},
"Buff-武器-精5街头巨星-终结技增伤": {
"module": ".BuffXLogic.StreetSuperstar",
"class": "StreetSuperstar"
},
"Buff-武器-精1强音热望-额外攻击力加成": {
"module": ".BuffXLogic.MarcatoDesireAtkBonus",
"class": "MarcatoDesireAtkBonus"
},
"Buff-武器-精2强音热望-额外攻击力加成": {
"module": ".BuffXLogic.MarcatoDesireAtkBonus",
"class": "MarcatoDesireAtkBonus"
},
"Buff-武器-精3强音热望-额外攻击力加成": {
"module": ".BuffXLogic.MarcatoDesireAtkBonus",
"class": "MarcatoDesireAtkBonus"
},
"Buff-武器-精4强音热望-额外攻击力加成": {
"module": ".BuffXLogic.MarcatoDesireAtkBonus",
"class": "MarcatoDesireAtkBonus"
},
"Buff-武器-精5强音热望-额外攻击力加成": {
"module": ".BuffXLogic.MarcatoDesireAtkBonus",
"class": "MarcatoDesireAtkBonus"
},
"Buff-武器-精1加农转子-附加伤害触发器": {
"module": ".BuffXLogic.CannonRotor",
"class": "CannonRotor"
},
"Buff-武器-精2加农转子-附加伤害触发器": {
"module": ".BuffXLogic.CannonRotor",
"class": "CannonRotor"
},
"Buff-武器-精3加农转子-附加伤害触发器": {
"module": ".BuffXLogic.CannonRotor",
"class": "CannonRotor"
},
"Buff-武器-精4加农转子-附加伤害触发器": {
"module": ".BuffXLogic.CannonRotor",
"class": "CannonRotor"
},
"Buff-武器-精5加农转子-附加伤害触发器": {
"module": ".BuffXLogic.CannonRotor",
"class": "CannonRotor"
},
"Buff-武器-精1「月相」-朔-回能触发器": {
"module": ".BuffXLogic.LunarNoviluna",
"class": "LunarNoviluna"
},
"Buff-武器-精2「月相」-朔-回能触发器": {
"module": ".BuffXLogic.LunarNoviluna",
"class": "LunarNoviluna"
},
"Buff-武器-精3「月相」-朔-回能触发器": {
"module": ".BuffXLogic.LunarNoviluna",
"class": "LunarNoviluna"
},
"Buff-武器-精4「月相」-朔-回能触发器": {
"module": ".BuffXLogic.LunarNoviluna",
"class": "LunarNoviluna"
},
"Buff-武器-精5「月相」-朔-回能触发器": {
"module": ".BuffXLogic.LunarNoviluna",
"class": "LunarNoviluna"
},
"Buff-角色-仪玄-额外能力-对失衡敌人增伤": {
"module": ".BuffXLogic.YixuanAdditionalAbilityDmgBonus",
"class": "YixuanAdditionalAbilityDmgBonus"
},
"Buff-角色-仪玄-1画-落雷触发器": {
"module": ".BuffXLogic.YixuanCinema1Trigger",
"class": "YixuanCinema1Trigger"
},
"Buff-角色-仪玄-2画-失衡时间提升": {
"module": ".BuffXLogic.YixuanCinema2StunTimeLimitBonus",
"class": "YixuanCinema2StunTimeLimitBonus"
},
"Buff-武器-精1青溟笼舍-以太伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionEthDmgBonus",
"class": "QingmingBirdcageCompanionEthDmgBonus"
},
"Buff-武器-精2青溟笼舍-以太伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionEthDmgBonus",
"class": "QingmingBirdcageCompanionEthDmgBonus"
},
"Buff-角色-仪玄-4画-静心": {
"module": ".BuffXLogic.YixuanCinema4Tranquility",
"class": "YixuanCinema4Tranquility"
},
"Buff-武器-精3青溟笼舍-以太伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionEthDmgBonus",
"class": "QingmingBirdcageCompanionEthDmgBonus"
},
"Buff-武器-精4青溟笼舍-以太伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionEthDmgBonus",
"class": "QingmingBirdcageCompanionEthDmgBonus"
},
"Buff-武器-精5青溟笼舍-以太伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionEthDmgBonus",
"class": "QingmingBirdcageCompanionEthDmgBonus"
},
"Buff-武器-精1青溟笼舍-贯穿伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionSheerAtkBonus",
"class": "QingmingBirdcageCompanionSheerAtkBonus"
},
"Buff-武器-精2青溟笼舍-贯穿伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionSheerAtkBonus",
"class": "QingmingBirdcageCompanionSheerAtkBonus"
},
"Buff-武器-精3青溟笼舍-贯穿伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionSheerAtkBonus",
"class": "QingmingBirdcageCompanionSheerAtkBonus"
},
"Buff-武器-精4青溟笼舍-贯穿伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionSheerAtkBonus",
"class": "QingmingBirdcageCompanionSheerAtkBonus"
},
"Buff-武器-精5青溟笼舍-贯穿伤害提升": {
"module": ".BuffXLogic.QingmingBirdcageCompanionSheerAtkBonus",
"class": "QingmingBirdcageCompanionSheerAtkBonus"
},
"Buff-驱动盘-云岿如我-四件套-贯穿伤害提升": {
"module": ".BuffXLogic.YunkuiTalesSheerAtkBonus",
"class": "YunkuiTalesSheerAtkBonus"
},
"Buff-武器-精1幻变魔方-强化E增伤": {
"module": ".BuffXLogic.PuzzleSphereExDmgBonus",
"class": "PuzzleSphereExDmgBonus"
},
"Buff-武器-精2幻变魔方-强化E增伤": {
"module": ".BuffXLogic.PuzzleSphereExDmgBonus",
"class": "PuzzleSphereExDmgBonus"
},
"Buff-武器-精3幻变魔方-强化E增伤": {
"module": ".BuffXLogic.PuzzleSphereExDmgBonus",
"class": "PuzzleSphereExDmgBonus"
},
"Buff-武器-精4幻变魔方-强化E增伤": {
"module": ".BuffXLogic.PuzzleSphereExDmgBonus",
"class": "PuzzleSphereExDmgBonus"
},
"Buff-武器-精5幻变魔方-强化E增伤": {
"module": ".BuffXLogic.PuzzleSphereExDmgBonus",
"class": "PuzzleSphereExDmgBonus"
},
"Buff-武器-精1「灰烬」-钴蓝-攻击力提升": {
"module": ".BuffXLogic.CinderCobaltAtkBonus",
"class": "CinderCobaltAtkBonus"
},
"Buff-武器-精2「灰烬」-钴蓝-攻击力提升": {
"module": ".BuffXLogic.CinderCobaltAtkBonus",
"class": "CinderCobaltAtkBonus"
},
"Buff-武器-精3「灰烬」-钴蓝-攻击力提升": {
"module": ".BuffXLogic.CinderCobaltAtkBonus",
"class": "CinderCobaltAtkBonus"
},
"Buff-武器-精4「灰烬」-钴蓝-攻击力提升": {
"module": ".BuffXLogic.CinderCobaltAtkBonus",
"class": "CinderCobaltAtkBonus"
},
"Buff-武器-精5「灰烬」-钴蓝-攻击力提升": {
"module": ".BuffXLogic.CinderCobaltAtkBonus",
"class": "CinderCobaltAtkBonus"
},
"Buff-角色-柚叶-甜蜜惊吓": {
"module": ".BuffXLogic.YuzuhaCorePassiveSweetScare",
"class": "YuzuhaCorePassiveSweetScare"
},
"Buff-角色-柚叶-硬糖射击触发器": {
"module": ".BuffXLogic.YuzuhaHardCandyShotTrigger",
"class": "YuzuhaHardCandyShotTrigger"
},
"Buff-角色-柚叶-彩糖花火积蓄值增加": {
"module": ".BuffXLogic.YuzuhaSugarBurstAnomalyBuildupBonus",
"class": "YuzuhaSugarBurstAnomalyBuildupBonus"
},
"Buff-角色-柚叶-彩糖花火·极积蓄值增加": {
"module": ".BuffXLogic.YuzuhaSugarBurstMaxAnomalyBuildupBonus",
"class": "YuzuhaSugarBurstMaxAnomalyBuildupBonus"
},
"Buff-角色-柚叶-核心被动-狸之愿-攻击力": {
"module": ".BuffXLogic.YuzuhaTanukiWishAtkBonus",
"class": "YuzuhaTanukiWishAtkBonus"
},
"Buff-角色-柚叶-组队被动-积蓄值增幅": {
"module": ".BuffXLogic.YuzuhaAdditionalAbilityAnomalyBuildupBonus",
"class": "YuzuhaAdditionalAbilityAnomalyBuildupBonus"
},
"Buff-角色-柚叶-组队被动-属性异常与紊乱伤害增幅": {
"module": ".BuffXLogic.YuzuhaAdditionalAbilityAnomalyDmgBonus",
"class": "YuzuhaAdditionalAbilityAnomalyDmgBonus"
},
"Buff-角色-柚叶-1画-全属性伤害抗性降低": {
"module": ".BuffXLogic.YuzuhaCinem1EleResReduce",
"class": "YuzuhaCinem1EleResReduce"
},
"Buff-角色-柚叶-2画-连携技触发器": {
"module": ".BuffXLogic.YuzuhaCinema2Trigger",
"class": "YuzuhaCinema2Trigger"
},
"Buff-角色-柚叶-4画-快支触发器": {
"module": ".BuffXLogic.YuzuhaCinema4QuickAssistTrigger",
"class": "YuzuhaCinema4QuickAssistTrigger"
},
"Buff-角色-柚叶-6画-炮弹触发器": {
"module": ".BuffXLogic.YuzuhaCinema6SheelTrigger",
"class": "YuzuhaCinema6SheelTrigger"
},
"Buff-角色-柚叶-6画-彩糖花火极触发器": {
"module": ".BuffXLogic.YuzuhaCinema6SugarBurstMaxTrigger",
"class": "YuzuhaCinema6SugarBurstMaxTrigger"
},
"Buff-武器-精1狸法七变化-全队异常精通": {
"module": ".BuffXLogic.MetanukiMorphosisAPBonus",
"class": "MetanukiMorphosisAPBonus"
},
"Buff-武器-精2狸法七变化-全队异常精通": {
"module": ".BuffXLogic.MetanukiMorphosisAPBonus",
"class": "MetanukiMorphosisAPBonus"
},
"Buff-武器-精3狸法七变化-全队异常精通": {
"module": ".BuffXLogic.MetanukiMorphosisAPBonus",
"class": "MetanukiMorphosisAPBonus"
},
"Buff-武器-精4狸法七变化-全队异常精通": {
"module": ".BuffXLogic.MetanukiMorphosisAPBonus",
"class": "MetanukiMorphosisAPBonus"
},
"Buff-武器-精5狸法七变化-全队异常精通": {
"module": ".BuffXLogic.MetanukiMorphosisAPBonus",
"class": "MetanukiMorphosisAPBonus"
},
"Buff-角色-爱丽丝-额外能力-异常掌控转精通": {
"module": ".BuffXLogic.AliceAdditionalAbilityApBonus",
"class": "AliceAdditionalAbilityApBonus"
},
"Buff-角色-爱丽丝-极性强击触发器": {
"module": ".BuffXLogic.AlicePolarizedAssaultTrigger",
"class": "AlicePolarizedAssaultTrigger"
},
"Buff-角色-爱丽丝-影画-6画-额外攻击触发器": {
"module": ".BuffXLogic.AliceCinema6Trigger",
"class": "AliceCinema6Trigger"
},
"Buff-角色-席德-强袭": {
"module": ".BuffXLogic.SeedOnslaughtBonus",
"class": "SeedOnslaughtBonus"
},
"Buff-角色-席德-明攻": {
"module": ".BuffXLogic.SeedDirectStrikeBonus",
"class": "SeedDirectStrikeBonus"
},
"Buff-角色-席德-明攻触发器": {
"module": ".BuffXLogic.SeedDirectStrikeTrigger",
"class": "SeedDirectStrikeTrigger"
},
"Buff-角色-席德-围杀": {
"module": ".BuffXLogic.SeedBesiegeBonus",
"class": "SeedBesiegeBonus"
},
"Buff-角色-席德-额外能力-重击大招增伤无视电抗": {
"module": ".BuffXLogic.SeedAdditionalAbilityTrigger",
"class": "SeedAdditionalAbilityTrigger"
},
"Buff-角色-席德-影画-2画-围杀无视防御力": {
"module": ".BuffXLogic.SeedCinema2BesiegeIgnoreDefense",
"class": "SeedCinema2BesiegeIgnoreDefense"
},
"Buff-角色-席德-影画-4画-喧响效率与大招增伤": {
"module": ".BuffXLogic.SeedCinema4Bonus",
"class": "SeedCinema4Bonus"
},
"Buff-角色-席德-影画-6画-触发器": {
"module": ".BuffXLogic.SeedCinema6Trigger",
"class": "SeedCinema6Trigger"
},
"Buff-武器-精1机巧心种-常驻暴击": {
"module": ".BuffXLogic.CordisGerminaCritRateBonus",
"class": "CordisGerminaCritRateBonus"
},
"Buff-武器-精2机巧心种-常驻暴击": {
"module": ".BuffXLogic.CordisGerminaCritRateBonus",
"class": "CordisGerminaCritRateBonus"
},
"Buff-武器-精3机巧心种-常驻暴击": {
"module": ".BuffXLogic.CordisGerminaCritRateBonus",
"class": "CordisGerminaCritRateBonus"
},
"Buff-武器-精4机巧心种-常驻暴击": {
"module": ".BuffXLogic.CordisGerminaCritRateBonus",
"class": "CordisGerminaCritRateBonus"
},
"Buff-武器-精5机巧心种-常驻暴击": {
"module": ".BuffXLogic.CordisGerminaCritRateBonus",
"class": "CordisGerminaCritRateBonus"
},
"Buff-武器-精1机巧心种-电属性增伤": {
"module": ".BuffXLogic.CordisGerminaEleDmgBonus",
"class": "CordisGerminaEleDmgBonus"
},
"Buff-武器-精2机巧心种-电属性增伤": {
"module": ".BuffXLogic.CordisGerminaEleDmgBonus",
"class": "CordisGerminaEleDmgBonus"
},
"Buff-武器-精3机巧心种-电属性增伤": {
"module": ".BuffXLogic.CordisGerminaEleDmgBonus",
"class": "CordisGerminaEleDmgBonus"
},
"Buff-武器-精4机巧心种-电属性增伤": {
"module": ".BuffXLogic.CordisGerminaEleDmgBonus",
"class": "CordisGerminaEleDmgBonus"
},
"Buff-武器-精5机巧心种-电属性增伤": {
"module": ".BuffXLogic.CordisGerminaEleDmgBonus",
"class": "CordisGerminaEleDmgBonus"
},
"Buff-武器-精1机巧心种-普攻大招无视防御": {
"module": ".BuffXLogic.CordisGerminaSNAAndQIgnoreDefense",
"class": "CordisGerminaSNAAndQIgnoreDefense"
},
"Buff-武器-精2机巧心种-普攻大招无视防御": {
"module": ".BuffXLogic.CordisGerminaSNAAndQIgnoreDefense",
"class": "CordisGerminaSNAAndQIgnoreDefense"
},
"Buff-武器-精3机巧心种-普攻大招无视防御": {
"module": ".BuffXLogic.CordisGerminaSNAAndQIgnoreDefense",
"class": "CordisGerminaSNAAndQIgnoreDefense"
},
"Buff-武器-精4机巧心种-普攻大招无视防御": {
"module": ".BuffXLogic.CordisGerminaSNAAndQIgnoreDefense",
"class": "CordisGerminaSNAAndQIgnoreDefense"
},
"Buff-武器-精5机巧心种-普攻大招无视防御": {
"module": ".BuffXLogic.CordisGerminaSNAAndQIgnoreDefense",
"class": "CordisGerminaSNAAndQIgnoreDefense"
},
"Buff-驱动盘-拂晓生花-四件套-触发普攻增伤": {
"module": ".BuffXLogic.DawnsBloom4SetTriggerNADmgBonus",
"class": "DawnsBloom4SetTriggerNADmgBonus"
},
"Buff-驱动盘-月光骑士颂-全队增伤": {
"module": ".BuffXLogic.MoonlightLullabyAllTeamDmgBonus",
"class": "MoonlightLullabyAllTeamDmgBonus"
},
"Buff-角色-席德-影画-2画-无视防御触发器": {
"module": ".BuffXLogic.SeedCinema2BesiegeIgnoreDefenceTrigger",
"class": "SeedCinema2BesiegeIgnoreDefenceTrigger"
},
"Buff-角色-席德-围杀触发器": {
"module": ".BuffXLogic.SeedBesiegeBonusTrigger",
"class": "SeedBesiegeBonusTrigger"
},
"Buff-角色-席德-影画-4画-触发器": {
"module": ".BuffXLogic.SeedCinema4Trigger",
"class": "SeedCinema4Trigger"
}
}
================================================
FILE: zsim/sim_progress/Character/Alice.py
================================================
from math import floor
from typing import TYPE_CHECKING
from zsim.define import ALICE_REPORT
from .character import Character
from .utils.filters import _skill_node_filter
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
class Alice(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.blade_etiquette: float = 300.0 # 剑仪
self.max_blade_etiquette: float = 300.0 # 最大剑仪值
self.victory_state_update_tick: int = 0 # 六画的决胜状态的更新时间
self.victory_state_duration: int = 1800 # 决胜状态持续时间
self.victory_state_activation_origin: list[str] = ["1401_SNA_3", "1401_Q"] # 决胜状态激活源
self.victory_state_attack_counter: int = 0 # 六画的决胜状态的剩余攻击次数
self.victory_state_max_attack_count: int = 6 # 六画的决胜状态的最大攻击次数
self.cinema_6_additional_attack_skill_tag: str = "1401_Cinema_6" # 6画额外攻击的技能tag
self._na_enhancement_state: bool = False # 强化平A可用状态
self.decibel = 1000.0 if self.cinema < 2 else 2000.0 # 爱丽丝喧响值
@property
def na_enhancement_state(self) -> bool:
"""强化平A是否可用"""
return self._na_enhancement_state
@na_enhancement_state.setter
def na_enhancement_state(self, value: bool) -> None:
"""强化平A状态的赋值函数"""
if not self._na_enhancement_state and not value:
raise ValueError(
"【爱丽丝时间警告】企图将强化平A状态从False切换到False，这意味着Preload在强化平A不可用的情况下放行了强化A5"
)
self._na_enhancement_state = value
@property
def victory_state(self) -> bool:
"""决胜状态是否处于激活状态"""
from zsim.simulator.simulator_class import Simulator
assert isinstance(self.sim_instance, Simulator), "角色未正确初始化，请检查函数"
# 攻击次数尚未耗尽，或是时间为0tick(未发生过更新)，此时的决胜状态都判定为False
if self.victory_state_update_tick == 0 or self.victory_state_attack_counter == 0:
return False
else:
# 层数没耗尽时，才检查时间条件
return (
self.sim_instance.tick - self.victory_state_update_tick
< self.victory_state_duration
)
@property
def blade_etquitte_bar(self) -> int:
# 剑仪条格子数（向下取整）
return floor(self.blade_etiquette / 100)
def reset_myself(self):
# 重置能量、喧响值
self.sp: float = 40.0
self.decibel: float = 1000.0 if self.cinema < 2 else 2000.0
# 重置动态属性
self.dynamic.reset()
def special_resources(self, *args, **kwargs) -> None:
"""爱丽丝的特殊资源模块"""
from zsim.simulator.simulator_class import Simulator
assert isinstance(self.sim_instance, Simulator), "角色未正确初始化，请检查函数"
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
if node.char_name == self.NAME:
# 6画情况下，优先更新决胜状态的相关参数
if self.cinema == 6:
if node.skill_tag in self.victory_state_activation_origin:
self.victory_state_update_tick = self.sim_instance.tick
self.victory_state_attack_counter = self.victory_state_max_attack_count
if ALICE_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【爱丽丝事件】【6画】检测到爱丽丝释放了{node.skill.skill_text}，激活了决胜状态"
)
# 更新强化A5状态
if node.skill_tag == "1401_NA_5_PLUS":
self.na_enhancement_state = False
if ALICE_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【爱丽丝事件】爱丽丝成功释放了一次强化A5：{node.skill.skill_text}，强化A5状态关闭"
)
# 更新剑仪值
self.update_blade_etiquette(update_obj=node)
else:
# 队友的skill_node判断；
pass
def update_blade_etiquette(self, update_obj: "SkillNode | float | int") -> None:
# 更新剑仪值的函数
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
assert isinstance(self.sim_instance, Simulator), "角色未正确初始化，请检查函数"
if update_obj is None:
raise ValueError("【剑仪值更新警告】在调用剑仪值更新函数时，必须传入update_obj参数")
if isinstance(update_obj, SkillNode):
if update_obj.labels is None:
raise ValueError(
f"【剑仪值更新警告】传入的{update_obj.skill_tag}没有初始化label参数，请检查数据库"
)
if "blade_etiquette" not in update_obj.labels:
print(
f"【剑仪值更新警告】技能{update_obj.skill_tag}的label中不包含剑仪值，请检查数据库"
)
return
blade_etiquette = update_obj.labels.get("blade_etiquette")
elif isinstance(update_obj, float | int):
blade_etiquette = update_obj
assert isinstance(blade_etiquette, float | int), "剑仪值更新函数传入的参数类型错误"
self.blade_etiquette = min(self.max_blade_etiquette, self.blade_etiquette + blade_etiquette)
if blade_etiquette == 0:
return
if ALICE_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【爱丽丝事件】爱丽丝 {'恢复' if blade_etiquette > 0 else '消耗'} 了 {abs(blade_etiquette):.2f} 点剑仪值，当前剑仪值为 {self.blade_etiquette:.2f}"
)
def POST_INIT_DATA(self, sim_instance: "Simulator"):
"""初始化爱丽丝的监听器组"""
listener_manager = sim_instance.listener_manager
# 组队被动激活时，初始化紊乱回剑仪值的监听器
if self.additional_abililty_active:
listener_manager.listener_factory(
listener_owner=self, initiate_signal="Alice_1", sim_instance=sim_instance
)
# 初始化本体固有监听器（紊乱倍率、物理积蓄效率）
for listener_id in ["Alice_2", "Alice_3", "Alice_4", "Alice_5"]:
listener_manager.listener_factory(
listener_owner=self, initiate_signal=listener_id, sim_instance=sim_instance
)
# 1画激活时，初始化1画监听器（减防Buff）
if self.cinema >= 1:
listener_manager.listener_factory(
listener_owner=self, initiate_signal="Alice_Cinema_1_A", sim_instance=sim_instance
)
listener_manager.listener_factory(
listener_owner=self, initiate_signal="Alice_Cinema_1_B", sim_instance=sim_instance
)
# 2画激活时，初始化2画监听器（紊乱伤害提升）
if self.cinema >= 2:
listener_manager.listener_factory(
listener_owner=self, initiate_signal="Alice_Cinema_2_A", sim_instance=sim_instance
)
def spawn_extra_attack(self) -> None:
"""6画额外攻击的接口，向Preload添加一次额外攻击事件，同时扣除一次使用次数"""
assert self.victory_state, "6画额外攻击接口调用时，决胜状态未激活，请检查前置判断逻辑"
assert self.sim_instance is not None, "角色未正确初始化，请检查函数"
from zsim.sim_progress.data_struct.SchedulePreload import schedule_preload_event_factory
preload_tick_list = [self.sim_instance.tick]
skill_tag_list = [self.cinema_6_additional_attack_skill_tag]
preload_data = self.sim_instance.preload.preload_data
schedule_preload_event_factory(
preload_tick_list=preload_tick_list,
skill_tag_list=skill_tag_list,
preload_data=preload_data,
sim_instance=self.sim_instance,
)
if ALICE_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【爱丽丝事件】【6画】队友攻击命中，爱丽丝触发额外攻击！当前剩余额外攻击次数：{self.victory_state_attack_counter}"
)
# 保险起见，计数器在最后更新
self.victory_state_attack_counter -= 1
def personal_action_replace_strategy(self, action: str):
"""爱丽丝的个人动作替换策略，其核心是：尝试把NA_5替换为它的强化版本"""
if action == "1401_NA_5":
if self.na_enhancement_state:
return "1401_NA_5_PLUS"
return action
def get_resources(self, *args, **kwargs) -> tuple[str, int]:
return "剑仪格", self.blade_etquitte_bar
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {"剑仪值": self.blade_etiquette, "强化A5状态": self.na_enhancement_state}
================================================
FILE: zsim/sim_progress/Character/AstraYao.py
================================================
import math
from typing import TYPE_CHECKING
from zsim.define import ASTRAYAO_REPORT
from zsim.sim_progress.Buff import JudgeTools
from zsim.sim_progress.data_struct import schedule_preload_event_factory
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
from .character import Character
from .utils.filters import _skill_node_filter
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class AstraYao(Character):
"""耀佳音的特殊资源模块"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.idyllic_cadenza = False # 咏叹华彩状态
self.chord_manager = ChordCoattackManager(self)
@property
def chord(self) -> int:
"""每拥有25点能量，耀嘉音将拥有1点[和弦]"""
return math.floor(self.sp / 25)
class Dynamic(Character.Dynamic):
"""
这里的所有修改，是为了让on_field属性能够完美适配咏叹华彩状态，
当咏叹华彩状态为True时，on_field属性永远返回True，
而当它为False时，on_field属性返回存储的值。
"""
def __init__(self, char_instantce: Character):
super().__init__(char_instantce)
self.character: "AstraYao" = char_instantce # type: ignore
self._on_field = False # 初始化父类的普通属性
@property
def on_field(self):
"""重写on_field属性，根据咏叹华彩状态返回不同值"""
if self.character.idyllic_cadenza: # 如果咏叹华彩状态为True
return True
return self._on_field # 否则返回存储的值
@on_field.setter
def on_field(self, value):
"""保留设置功能"""
self._on_field = value
def __update_idyllic_cadenza(self, skill_node: "SkillNode") -> None:
"""更新咏叹华彩状态"""
if skill_node.skill_tag in ["1311_E_A", "1311_QTE", "1311_Q"]:
self.idyllic_cadenza = True
elif "1311_NA_3" in skill_node.skill_tag:
self.idyllic_cadenza = False
def special_resources(self, *args, **kwargs) -> None:
# 输入类型检查
skill_nodes: list["SkillNode"] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
self.__update_idyllic_cadenza(node)
pass
def get_resources(self) -> tuple[str, int]:
return "咏叹华彩", self.idyllic_cadenza
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {"和弦": self.chord}
"""================================分割线=================================="""
class ChordCoattackManager:
def __init__(self, char_instance: AstraYao):
self.char = char_instance
self.quick_assist_trigger_manager = self.QuickAssistTriggerManager(self.char)
self.chord_trigger = self.ChordTrigger(self)
class QuickAssistTriggerManager:
"""快速支援管理器"""
def __init__(self, char_instance: AstraYao):
self.char = char_instance
self.light_attack_trigger = self.BaseSingleTrigger(
self, cd=180 if self.char.cinema < 4 else 60
)
self.heavy_attack_trigger = self.BaseSingleTrigger(self, cd=60)
self.found_char_dict: dict[str, Character] = {}
self.preload_data: PreloadData | None = None
def update_myself(self, tick: int, event):
"""这个函数的作用是更新自身状态，并且尝试触发轻、重两种快速支援触发器。"""
from zsim.sim_progress.Load import LoadingMission
from zsim.sim_progress.Preload import SkillNode
if isinstance(event, LoadingMission):
skill_node = event.mission_node
elif isinstance(event, SkillNode):
skill_node = event
else:
return
# 处理loading_mission为None的情况
if skill_node.loading_mission is None:
skill_node.loading_mission = LoadingMission(skill_node)
skill_node.loading_mission.mission_start(tick, report=False)
# # 检查当前tick是否为命中tick
# if not skill_node.loading_mission.is_hit_now(tick):
# raise ValueError(
# f"在非命中tick {tick} 上调用了耀嘉音快支管理器中的update_myself方法，当前的命中tick列表为：{skill_node.loading_mission.mission_dict}"
# )
# 根据轻重攻击情况触发快速支援
if skill_node.loading_mission.is_heavy_hit(tick):
self.heavy_attack_trigger.try_active(tick, skill_node)
else:
self.light_attack_trigger.try_active(tick, skill_node)
class BaseSingleTrigger:
"""单个触发器类"""
def __init__(self, manager_instance, cd: int):
self.manager: ChordCoattackManager.QuickAssistTriggerManager = manager_instance
self.cd = cd
self.last_update_tick = 0
def is_ready(self, tick: int):
if self.last_update_tick == 0:
return True
if tick - self.last_update_tick >= self.cd:
return True
else:
return False
def determine_target_char(self, tick: int):
"""
根据当前角色和角色顺序确定目标角色，这里需要分两种情况讨论：
1、下一个角色是耀嘉音——跳过耀嘉音，直接触发下下位角色的快速支援，
2、下一个角色不是耀嘉音——正常触发下一位角色的快速支援。
"""
assert self.manager.preload_data is not None, "preload_data is not initialized"
_operating_node = self.manager.preload_data.get_on_field_node(tick)
all_name_order_box = self.manager.preload_data.load_data.all_name_order_box
if _operating_node is None:
raise ValueError("想要触发耀嘉音的快速支援，则当前场上必须存在角色！")
current_name_order = all_name_order_box[_operating_node.char_name]
if current_name_order[1] == "耀嘉音":
target = current_name_order[2]
else:
target = current_name_order[1]
# print(_operating_node.skill_tag, current_name_order, target)
return target
def __active(self, tick: int, skill_node):
"""触发快速支援！不包含CD判断，只包含触发逻辑。"""
if self.manager.preload_data is None:
if self.manager.char.sim_instance is None:
raise ValueError("sim_instance is None, cannot find preload_data")
self.manager.preload_data = JudgeTools.find_preload_data(
sim_instance=self.manager.char.sim_instance
)
if not isinstance(self.manager.preload_data, PreloadData):
raise TypeError("快速支援管理器无法找到PreloadData实例！")
self.last_update_tick = tick
target_char = self.determine_target_char(tick)
assert self.manager.preload_data.quick_assist_system is not None
self.manager.preload_data.quick_assist_system.force_active_quick_assist(
tick, skill_node, target_char
)
def try_active(self, tick: int, skill_node):
"""尝试触发快速支援！这是给外部调用的接口。"""
if self.manager.char.chord < 1 or not self.manager.char.idyllic_cadenza:
"""当耀嘉音的和弦数量不足、或不处于唱歌状态时，不予触发！"""
return False
if not self.is_ready(tick):
return
self.__active(tick, skill_node)
class ChordTrigger:
def __init__(self, manager_instance):
self.manager: ChordCoattackManager = manager_instance
self.preload_data: PreloadData | None = None
# 震音：Tremolo；音簇：Tone Clusters
self.tremolo_tick = 35 # 震音的总时长
self.tone_clusters_tick = 50 # 音簇的总时长
self.coattack_base_count = (
1 if not self.manager.char.additional_abililty_active else 2
) # 震音的基础轮次
self.c2_update_tick = 0
self.c2_trigger_cd = 180
self.core_passive_buff_index = "Buff-角色-耀佳音-核心被动-攻击力"
self.last_chord_update_tick = 0 # 上一次调用和弦构造函数的时间点！
self.tremolo_tag = "1311_E_EX_A"
self.free_tremolo_tag = "1311_E_EX_A_FREE"
self.tone_clusters_tag = "1311_E_EX_C"
def c2_ready(self, tick: int):
return tick - self.c2_update_tick >= self.c2_trigger_cd
def try_spawn_chord_coattack(self, tick: int, skill_node: "SkillNode | None"):
"""给外部的接口，尝试执行！"""
if self.manager.char.sp < 25:
return
self.coattack_active(tick, skill_node)
def coattack_active(self, tick: int, skill_node: "SkillNode | None"):
"""
给外部函数调用的接口，用于生成协同攻击。
如果有顺带传入skill_node参数，则意味着调用来自Buff系统的触发器，
此时，协同攻击预载行为往往伴随着耀嘉音核心被动攻击力Buff的刷新。
"""
c2_count = 1 if self.manager.char.cinema >= 2 else 0
loop_times = self.coattack_base_count + c2_count
self.__chord_group_spawn_loop(tick, loop_times)
if skill_node is not None:
self.__add_core_passive_buff(skill_node)
def __chord_group_spawn_loop(self, tick: int, loop_times: int):
"""
用于抛出成组的和弦攻击，每组动作包含1次震音、3次音簇。
并且可以进行重复执行，模仿耀嘉音技能模组中，多次触发的情况。
"""
if self.preload_data is None:
if self.manager.char.sim_instance is None:
raise ValueError("sim_instance is None, cannot find preload_data")
self.preload_data = JudgeTools.find_preload_data(
sim_instance=self.manager.char.sim_instance
)
if not isinstance(self.preload_data, PreloadData):
raise TypeError("和弦管理器无法找到PreloadData实例！")
priority_list = [-1, -1]
preload_tick = tick
for i in range(loop_times):
if i == 2:
if self.c2_ready(tick):
self.c2_update_tick = tick
else:
"""针对2画，这里需要注意内置CD的判断"""
continue
if i == 0:
skill_tag_list = [self.tremolo_tag, self.tone_clusters_tag]
else:
skill_tag_list = [self.free_tremolo_tag, self.tone_clusters_tag]
skill_preload_tick_list = [
preload_tick,
preload_tick + self.tremolo_tick,
]
preload_tick += self.tremolo_tick + self.tone_clusters_tick
if self.manager.char.sim_instance is None:
raise ValueError("sim_instance is None, cannot schedule event")
schedule_preload_event_factory(
skill_tag_list=skill_tag_list,
preload_tick_list=skill_preload_tick_list,
preload_data=self.preload_data,
apl_priority_list=priority_list,
sim_instance=self.manager.char.sim_instance,
)
def __add_core_passive_buff(self, skill_node: "SkillNode"):
"""在触发第一次震音的时刻，也会给角色上Buff"""
add_buff_list = [self.manager.char.NAME] + [skill_node.char_name]
benifit_list = list(set(add_buff_list))
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
if self.manager.char.sim_instance is None:
raise ValueError("sim_instance is None, cannot add buff")
buff_add_strategy(
self.core_passive_buff_index,
benifit_list=benifit_list,
sim_instance=self.manager.char.sim_instance,
)
if ASTRAYAO_REPORT:
assert self.manager.char.sim_instance is not None
self.manager.char.sim_instance.schedule_data.change_process_state()
print(f"核心被动触发器激活！为{benifit_list}添加了{self.core_passive_buff_index}！")
================================================
FILE: zsim/sim_progress/Character/Ellen.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.Report import report_to_log
from .character import Character
from .utils.filters import _skill_node_filter
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class Ellen(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.flash_freeze: int = 0
def special_resources(self, *args, **kwargs) -> None:
"""模拟艾莲的急冻充能"""
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
if "1191" not in node.skill_tag:
continue
if node.skill_tag in ["1191_SNA_1", "1191_SNA_2", "1191_SNA_3"]:
self.flash_freeze -= 1
if self.flash_freeze < 0:
report_to_log(
f"[Character] 释放 {node.skill_tag} 时，{self.NAME}的急冻充能不足，请检查技能树"
)
if self.flash_freeze < 3:
if node.skill_tag in ["1191_E_EX", "1191_E_EX_A", "1191_RA_NFC"]:
self.flash_freeze += 1
report_to_log(f"[Character] {self.NAME}的急冻充能被更新为：{self.flash_freeze}")
if node.skill_tag == "1191_RA_FC":
self.flash_freeze += 3
report_to_log(f"[Character] {self.NAME}的急冻充能被更新为：{self.flash_freeze}")
self.flash_freeze = max(self.flash_freeze, 0)
self.flash_freeze = min(self.flash_freeze, 3)
def get_resources(self, *args, **kwargs) -> tuple[str | None, int | float | None]:
return "急冻充能", self.flash_freeze
================================================
FILE: zsim/sim_progress/Character/Hugo.py
================================================
from .character import Character
class Hugo(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
# 虽然雨果自身没有特殊资源，但是需要创建他的专属监听器
self.listener_creat = False
def special_resources(self, *args, **kwargs) -> None:
"""雨果的特殊资源模块"""
if not self.listener_creat:
assert self.sim_instance is not None
self.sim_instance.listener_manager.listener_factory(
listener_owner=self,
initiate_signal="Hugo",
sim_instance=self.sim_instance,
)
return
def get_resources(self) -> tuple[str | None, int | float | bool | None]:
return "特殊资源", 0.0
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {}
================================================
FILE: zsim/sim_progress/Character/Jane.py
================================================
from zsim.sim_progress.Preload import SkillNode
from .character import Character
from .utils.filters import _skill_node_filter
class Jane(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.passion_stream: float = 0.0 # 狂热心流，0.0 ~ 100.0
self.passion_state: bool = False # 狂热状态
self.salchow_jump: int = 0 # 萨霍夫跳剩余次数
def __check_salchow_jump(self) -> None:
"""检查萨霍夫跳次数"""
max_jumps = 1 if self.cinema == 0 else 2
if self.salchow_jump > max_jumps:
self.salchow_jump = max_jumps
elif self.salchow_jump < 0:
raise RuntimeError("萨霍夫跳次数不能为负数")
def __reset_passion(self) -> None:
"""重置狂热"""
self.passion_stream = 0.0
self.passion_state = False
self.__check_salchow_jump()
def __get_into_passion_state(self) -> None:
"""进入狂热状态"""
self.passion_stream = 100
self.passion_state = True
self.salchow_jump += 1
self.__check_salchow_jump()
def __passion_core(
self, passion_get: float, passion_consume: float, passion_direct_add: float
) -> None:
"""狂热计算逻辑核心"""
self.passion_stream += passion_direct_add # 直接添加的狂热值，闪反、QTE、大招、萨霍夫跳等
if not self.passion_state:
# 非狂热心流状态下，结算狂热获得
self.passion_stream += passion_get
if self.passion_stream >= 100 - 1e-6:
self.__get_into_passion_state()
else:
# 狂热心流状态下，结算狂热消耗
self.passion_stream -= passion_consume
if self.passion_stream <= 1e-6:
self.__reset_passion()
def special_resources(self, *args, **kwargs) -> None:
"""模拟简的狂热心流"""
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
if node.char_name != "简":
continue
if node.skill_tag == "1261_SNA_1":
self.salchow_jump -= 1
self.__check_salchow_jump()
labels: dict[str, list[str] | str | int | float] = (
node.labels if node.labels is not None else {}
)
passion_get: float = float(labels.get("passion_get", 0)) # type: ignore
passion_consume: float = float(labels.get("passion_consume", 0)) # type: ignore
passion_direct_add: float = float(labels.get("passion_direct_add", 0)) # type: ignore
self.__passion_core(passion_get, passion_consume, passion_direct_add)
# TODO 关于萨霍夫跳的第一段（1261_SNA_1）的拆分问题：
# 这一段攻击动作是可以提前停止的，
# 所以我在考虑要不要在数据库中对该动作进行拆分——就像青衣的 NA_3 一样，只记录最小单位。
# 因为开大抢队、或是即将到来的怪物进攻以及角色交互模块（估计在5月份我就一定会写），一定会涉及到各种动作的提前终止，
# 虽然就目前的结构来说，提前终止在伤害、积蓄、失衡端都是已经可以满足的（我给Load阶段留了接口，可以调用函数暴力删除某个正在进行的动作），
# 但是在特殊资源这一块，技能一旦传入就会拿到100%份额的心流恢复，这里和实战中提前打断萨霍夫跳的情况会有一定出入——这会干扰到后续APL对整个循环的递推。
# 当然，现阶段可以不做这个，让简每次都打完完整的萨霍夫跳
# 但是，类似于这种可重复的蓄力类动作的拆分，可以说是通用需求。在简这里碰到的问题，在其他角色那里一样会碰到，
# ---分割线---
# 如果要拆的话，显然就要涉及一个判断“1261_SNA_1的首次传入”的需求，
# 那可以看看char下面的lasting_node，那里的数据结构可以帮助你快速判断这个“首次传入”，就不需要在本地写一堆轮子了。
# if self.cinema == 6:
# pass
# TODO 六命后强击立刻进入狂热心流——由外部模块控制，调用接口强制启动心流即可，不需要在本函数中留接口。
def external_passion_change(self):
"""
外部强制开启心流状态的接口——主要为6画服务，尚未debug！！！这里只是留一个接口。
至于为何要单写一个函数，因为要调用的是“__”开头的私有方法，直接调用IDE会报错，按照格式调用又不美观，索性单写一个函数
"""
self.__get_into_passion_state()
def get_resources(self) -> tuple[str, float]:
return "狂热心流", self.passion_stream
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
"""获取简的特殊状态"""
return {
"狂热心流": self.passion_stream,
"狂热状态": self.passion_state,
"萨霍夫跳剩余次数": self.salchow_jump,
}
================================================
FILE: zsim/sim_progress/Character/Lighter.py
================================================
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Report import report_to_log
from .character import Character
from .utils.filters import _skill_node_filter
class Lighter(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.morale: int | float = 4000 # 士气初始40 整形为4000
self.last_tick: int = 0
def special_resources(self, *args, **kwargs) -> None:
"""
模拟莱特的士气机制
判断目前的时间，与上一次激活时做差，并更新士气值
确保士气值不超过100
将传入的skill_node消耗的能量转为士气值
需要消耗士气时对应扣除
"""
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
# 对输入的skill_node进行遍历
for node in skill_nodes:
# 累加逻辑
if self.morale < 10000:
# 消耗能量及时更新
sp_consume = node.skill.sp_consume
if sp_consume > 0:
self.morale += sp_consume * 26
# print(
# f"检测到队友强化E{node.skill_tag}：当前士气：{self.morale / 100:.2f}"
# )
if "1161" not in node.skill_tag:
continue
# 递减逻辑
if node.skill_tag == "1161_NA_5_SH_EX":
self.morale -= 1000
report_to_log(f"[Character] 莱特的士气消耗至 {self.morale / 100:.2f}")
elif node.skill_tag == "1161_NA_5_CoH_EX":
self.morale -= 9000
# print(f'检测到士气消耗动作，当前士气（处理前）：{self.morale}（处理后）：{self.morale / 100:.2f}')
# TODO：这里需要一个函数来控制“夹断”技能的数据。思路：\n
# 1、根据当前SkillNode类复制一个出来（__dict__），\n
# 2、根据资源消耗量算出缩放比例，\n
# 3、根据缩放比例修改新的复制SkillNode的所有数据。\n
# 4、传给下一个环节。
# FIXME: 20241208：
# 观察到莱特的士气貌似只有首轮具有阈值，次轮开始就失效了
report_to_log(f"[Character] 莱特的士气消耗至 {self.morale / 100:.2f}")
if self.morale < 0:
report_to_log(f"[Character] 莱特的士气消耗至 {self.morale / 100:.2f}, 请检查")
self.morale = 0
# 时间每 6 ticks 更新
assert self.sim_instance is not None
tick: int = self.sim_instance.tick
if tick is not None:
if (minus := tick - self.last_tick) >= 6:
self.morale += minus // 6 * 29 # 地板除保证整形对齐
self.last_tick = tick - minus % 6 # 求余以保证余数不计入本次计算
self.morale = min(self.morale, 10000)
def get_resources(self) -> tuple[str, float]:
return "士气", self.morale / 100
================================================
FILE: zsim/sim_progress/Character/Miyabi.py
================================================
from typing import Literal
from zsim.sim_progress.anomaly_bar import Disorder
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Report import report_to_log
from .character import Character
from .utils.filters import _skill_node_filter
def _disorder_counter(*args, **kwargs) -> int:
"""用于计算输入中紊乱的次数"""
counter: int = 0
for arg in args:
if isinstance(arg, Disorder):
counter += 1
for value in kwargs.values():
if isinstance(value, Disorder):
counter += 1
return counter
class Miyabi(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.last_tick: int | None = None
self.frosty: int = 3
def special_resources(self, *args, **kwargs) -> None:
"""模拟雅的落霜机制"""
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
if "1091" not in node.skill_tag:
continue
if self.frosty <= 6:
if node.skill_tag in ["1091_E_EX_A_1", "1091_E_EX_B_1"]:
self.frosty += 2
elif node.skill_tag == "1091_Core_Passive" and not self._shatter_internal_cd():
"""
霜灼·破的产生，在冰焰buff的exist逻辑里。
在exist逻辑返回True之前，会把霜灼破扔给special_resources以及eventlist
"""
self.frosty += 1
elif node.skill_tag == "1091_Q":
self.frosty += 3
else:
self.frosty = 6
if node.skill_tag == "1091_SNA_1":
self.frosty -= 2
elif node.skill_tag == "1091_SNA_2":
self.frosty -= 4
elif node.skill_tag == "1091_SNA_3":
self.frosty -= 6
if self.frosty < 0:
log = f"[Character] {self.NAME}的落霜不足，被消耗至{self.frosty}点，已重置，请检查技能树"
print(log)
report_to_log(log)
self.frosty = 0
if self.frosty <= 6:
disorder_times = _disorder_counter(*args, **kwargs)
self.frosty += disorder_times * 2
self.frosty = min(self.frosty, 6)
def _shatter_internal_cd(self) -> bool:
"""判断落霜叠层是否处于CD"""
assert self.sim_instance is not None
tick: int = self.sim_instance.tick
if self.last_tick is None:
self.last_tick = tick
return False
if tick - self.last_tick < 60:
return True
else:
self.last_tick = tick
return False
def get_resources(self) -> tuple[Literal["落霜"], int]:
return "落霜", self.frosty
================================================
FILE: zsim/sim_progress/Character/Qingyi.py
================================================
from zsim.sim_progress.Preload import SkillNode
from .character import Character
from .utils.filters import _skill_node_filter
class Qingyi(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.__MAX_VOLTAGE: int = 10000
self.__QUAN_VOLTAGE: float = self.__MAX_VOLTAGE / 100 * (1.3 if self.cinema >= 1 else 1)
self.__FLASH_THRESHOLD: float = self.__MAX_VOLTAGE * 0.75
self.VOLTAGE_MAP: dict = {
"1251_NA_3_NFC": self.__QUAN_VOLTAGE * 4.6875,
"1251_NA_3_FC": self.__QUAN_VOLTAGE * 4.6875 * 16,
"1251_SNA": self.__QUAN_VOLTAGE * 1.94,
"1251_NA_4": self.__QUAN_VOLTAGE * 7.7,
"1251_CA": self.__QUAN_VOLTAGE * 16.08,
"1251_BH_Aid": self.__QUAN_VOLTAGE * 6.08,
"1251_Assault_Aid": self.__QUAN_VOLTAGE * 14.89,
"1251_E": self.__QUAN_VOLTAGE * 2.83,
"1251_E_EX_NFC": self.__QUAN_VOLTAGE * 22.29,
"1251_E_EX_FC": self.__QUAN_VOLTAGE * 30,
"1251_QTE": self.__QUAN_VOLTAGE * 25,
"1251_Q": self.__QUAN_VOLTAGE * 80,
}
self.flash_connect_voltage: float = (
0 if self.cinema == 0 else self.__MAX_VOLTAGE
) # 闪络电压，初始化为0
self.flash_connect: bool = False if self.cinema == 0 else True # 闪络状态
self.rush_attack_available_times: int = 5 # 醉花月云转-突进攻击可用次数
def special_resources(self, *args, **kwargs) -> None:
"""模拟青衣的闪络电压机制"""
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
# 闪络电压增加逻辑
if self.flash_connect_voltage < self.__MAX_VOLTAGE:
skill_tag = node.skill_tag
self.flash_connect_voltage += self.VOLTAGE_MAP.get(skill_tag, 0)
# 闪络电压不能超过最大值
self.flash_connect_voltage = min(self.flash_connect_voltage, self.__MAX_VOLTAGE)
# 闪络电压超过75%时，进入闪络状态
if self.flash_connect_voltage - self.__FLASH_THRESHOLD >= 1e-5:
self.flash_connect = True
self.rush_attack_available_times = 5
if self.flash_connect:
# 闪络状态执行逻辑
if node.skill_tag == "1251_SNA_1":
self.flash_connect_voltage = 0
self.rush_attack_available_times -= 1
self.flash_connect = False
else:
# 非闪络状态执行逻辑
if node.skill_tag == "1251_SNA_1":
# 醉花月云转-突进攻击可用次数减一
if self.rush_attack_available_times in [0, 5]:
print(
f"WTF APL is doing? rush_attack_available_times is {self.rush_attack_available_times}"
)
self.rush_attack_available_times -= 1
def get_resources(self, *args, **kwargs) -> tuple[str, float]:
result = self.flash_connect_voltage / self.__MAX_VOLTAGE * 100
return "闪络电压", result
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {
"闪络电压": self.flash_connect_voltage / self.__MAX_VOLTAGE, # 返回一个比例
"闪络状态": self.flash_connect,
"醉花月云转可用次数": self.rush_attack_available_times,
}
================================================
FILE: zsim/sim_progress/Character/Seed/ExStateManager.py
================================================
from typing import TYPE_CHECKING
from ....define import SEED_REPORT
from ..character import Character
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class SeedEXState:
"""席德强化E释放的**当前**状态"""
IDLE = "idle" # 未开始强化E
FIRST_CAST = "first" # 第一段 (E_EX_0)
LOOPING = "looping" # 循环段 (E_EX_1)
INTRUPTED = "interrupted" # 中途打断 (E_EX_2)
FINISH = "finish" # 完整结束(SNA_1)
class SeedEXStateManager:
def __init__(self, char_instance: Character):
self.char = char_instance
assert self.char.NAME == "席德", (
f"SeedEXStateManager 仅支持席德, 当前角色为 {self.char.NAME}"
)
from . import Seed
assert type(self.char) is Seed
self.e_ex_max_repeat_times: int = 10 if self.char.cinema < 2 else 20
self.allowed_list = ["1461_E_EX_0", "1461_E_EX_1", "1461_E_EX_2", "1461_SNA_1"]
self._e_ex_state = SeedEXState.IDLE
self.repeat_count = 0 # 当前E_EX_1的重复次数
self.state_mapping = {
SeedEXState.IDLE: "1461_E_EX_0",
SeedEXState.FIRST_CAST: "1461_E_EX_1",
SeedEXState.LOOPING: "1461_E_EX_1",
SeedEXState.INTRUPTED: "1461_E_EX_0",
SeedEXState.FINISH: "1461_SNA_1",
}
self.cinema_2_buff_index = "Buff-角色-席德-影画-2画-耗能转化增伤"
@property
def e_ex_state(self) -> str:
return self._e_ex_state
@e_ex_state.setter
def e_ex_state(self, value: SeedEXState):
"""设置强化E释放的当前状态"""
self._e_ex_state = value
def update_ex_state(self, skill_node: "SkillNode"):
"""根据当前状态更新EX状态"""
# 由于非主动动作永远不可能在在强化E期间插入，但是额外伤害类技能是可以的，所以这里我们排除一下，避免干扰误触断言。
if skill_node.is_additional_damage:
return
if skill_node.skill_tag in self.allowed_list:
if skill_node.skill_tag == "1461_E_EX_0":
assert self.e_ex_state not in [SeedEXState.LOOPING, SeedEXState.FIRST_CAST], (
f"席德的强化E释放状态状态错误, 当前状态为 {self.e_ex_state}"
)
self.e_ex_state = SeedEXState.FIRST_CAST
self.repeat_count = 0 # 在检测到起手式时重置重复次数
elif skill_node.skill_tag == "1461_E_EX_1":
assert self.e_ex_state not in [
SeedEXState.IDLE,
SeedEXState.INTRUPTED,
SeedEXState.FINISH,
], f"席德的强化E释放状态状态错误, 当前状态为 {self.e_ex_state}"
assert self.repeat_count < self.e_ex_max_repeat_times, (
f"席德的强化E释放状态状态错误, 重复次数超过最大次数 {self.e_ex_max_repeat_times}"
)
self.repeat_count += 1
self.e_ex_state = (
SeedEXState.LOOPING
if self.repeat_count < self.e_ex_max_repeat_times
else SeedEXState.FINISH
)
elif skill_node.skill_tag == "1461_E_EX_2":
assert self.e_ex_state in [SeedEXState.LOOPING, SeedEXState.FIRST_CAST], (
f"席德的强化E释放状态状态错误, 当前状态为 {self.e_ex_state}"
)
assert self.repeat_count < self.e_ex_max_repeat_times, (
f"席德的强化E释放状态状态错误, 既然打出了E_EX_2就说明提前打断了强化E释放，此时释放次数（{self.repeat_count}次）应小于最大次数{self.e_ex_max_repeat_times}"
)
# print(22222, f"{self.char.sim_instance.tick}tick：检测到1461_E_EX_2，强化E状态从{self.e_ex_state}切换到{SeedEXState.INTRUPTED}")
self.e_ex_state = SeedEXState.INTRUPTED
elif skill_node.skill_tag == "1461_SNA_1":
if self.e_ex_state == SeedEXState.IDLE:
# 若是传入了第一段重击，同时强化E状态为IDLE，说明此次SNA_1和强化E连段无关，直接返回
return
else:
assert self.e_ex_state in [SeedEXState.FINISH, SeedEXState.INTRUPTED], (
f"席德的强化E释放状态状态错误, 当前状态为 {self.e_ex_state}"
)
self.e_ex_state = SeedEXState.IDLE
if self.char.cinema >= 2:
if SEED_REPORT:
self.char.sim_instance.schedule_data.change_process_state()
print(
f"【席德2画报告】检测到强化E结束，本次强化E共耗能{self.repeat_count * 5:.0f}点，将为本次自动衔接的 {skill_node.skill.skill_text} 提供{self.repeat_count * 5:.0f}%的增伤！"
)
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
benefit_list = ["席德"]
buff_add_strategy(
self.cinema_2_buff_index,
benifit_list=benefit_list,
specified_count=self.repeat_count,
sim_instance=self.char.sim_instance,
)
else:
assert self.e_ex_state not in [SeedEXState.LOOPING, SeedEXState.FIRST_CAST], (
f"在传入其他无关技能时，席德的强化E状态处于未结算的情况，当前状态为{self.e_ex_state}"
)
if self.e_ex_state in [SeedEXState.FINISH, SeedEXState.INTRUPTED]:
self.e_ex_state = SeedEXState.IDLE
def action_replacement_handler(self, action: str):
"""根据当前强化E状态，转换为对应强化E技能index"""
state = self.e_ex_state
# 对于不是席德的动作，直接返回
if "1461" not in action:
return action
if action in ["1461_E_EX_0", "1461_E_EX_1", "1461_E_EX_2"]:
action = "1461_E_EX"
if action == "1461_E_EX":
result = self.state_mapping[state]
# print(f"{self.char.sim_instance.tick}tick：强化E状态为{state}，指令{action}被替换为了{result}")
return result
else:
if state in [SeedEXState.LOOPING, SeedEXState.FIRST_CAST]:
# print(1111, f"在{self.char.sim_instance.tick}tick 指令{action}被替换为了1461_E_EX_2")
return "1461_E_EX_2"
else:
return action
================================================
FILE: zsim/sim_progress/Character/Seed/__init__.py
================================================
from typing import TYPE_CHECKING
from zsim.define import SEED_REPORT
from ..character import Character
from ..utils.filters import _skill_node_filter
from .ExStateManager import SeedEXStateManager
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
class Seed(Character):
def __init__(self, **kwargs):
"""
Seed的特殊机制
"""
super().__init__(**kwargs)
self._steel_charge: float = 60.0 if self.cinema < 1 else 100.0 # 钢能值
self.max_steel_charge: int = 150 # 最大钢能值
self.sna_steel_charge_cost: int = (
60 if self.cinema < 1 else 50
) # 落华·崩坠一式、二式消耗的钢能值
self.sp_to_steel_ratio: float = 0.5 # 技能能耗转换为钢能值的比例
self.Q_steel_charge_get: int = 60 if self.cinema < 1 else 80 # Q技能获得的钢能值
self.vanguard: Character | None = None # 正兵
self.sna_quick_release: bool = False # sna的快速释放状态
# 特殊状态组
self._onslaught: bool = False # 强袭状态
self._onslaught_active_tick: int = 0 # 强袭状态激活的tick
self._direct_strike: bool = False # 明攻状态
self._direct_strike_active_tick: int = 0 # 明攻状态激活的tick
self.special_state_duration: int = 2400 # 特殊状态持续时间`
self.state_keep_tick: int = 180 # 特殊状态在后台保持的tick
"""
注意，我并未设计某函数来赋予明攻、强袭状态为False值，因为整个模拟器的结构不太方便每个tick都来判断一次是否状态是否过期。
所以，这两个状态的赋值只会是赋予True值，而不会是赋予False值。
但是我设计了一个属性来记录这两个状态的激活tick，所以我可以在需要判断状态是否过期时，用当前tick减去激活tick，
如果大于特殊状态持续时间，那么就认为状态过期。
"""
self.sesm = SeedEXStateManager(char_instance=self)
@property
def onslaught(self) -> bool:
"""强袭状态"""
assert self.sim_instance is not None
if not self._onslaught:
return False
else:
tick = self.sim_instance.tick
if tick - self._onslaught_active_tick > self.special_state_duration:
return False
else:
return True
@property
def direct_strike(self) -> bool:
"""明攻状态"""
assert self.sim_instance is not None
if not self._direct_strike:
return False
else:
tick = self.sim_instance.tick
if tick - self._direct_strike_active_tick > self.special_state_duration:
return False
else:
return True
@onslaught.setter
def onslaught(self, value: bool) -> None:
"""强袭状态在检测到赋予True值时记录当前tick"""
assert self.sim_instance is not None
self._onslaught = value
if value:
self._onslaught_active_tick = self.sim_instance.tick
@direct_strike.setter
def direct_strike(self, value: bool) -> None:
"""明攻状态在检测到赋予True值时记录当前tick"""
assert self.sim_instance is not None
self._direct_strike = value
if value:
self._direct_strike_active_tick = self.sim_instance.tick
@property
def direct_strike_active(self) -> bool:
"""明攻状态是否生效：哪怕明攻状态激活，也会因为退场时间超过3秒而失效，所以必须单独判断"""
# 作为正兵的专属状态，若正兵本不存在，则直接返回False
if self.vanguard is None:
return False
# 当明攻状态为False时，直接返回False
if not self.direct_strike:
return False
# 当明攻状态为激活时，则需要判断正兵是否处于前台，或是退场的3秒以内。
# 若正兵处于前台，则直接返回True
if self.vanguard.dynamic.on_field:
return True
# 若正兵处于后台，则需要判断退场时间
# 当正兵退场时间小于等于3秒时，返回True
if self.vanguard.dynamic.is_off_field_within(max_ticks=self.state_keep_tick):
return True
# 当正兵退场时间大于3秒时，返回False
else:
return False
@property
def onslaught_active(self) -> bool:
"""强袭状态是否生效：哪怕强袭状态激活，也会因为退场时间超过3秒而失效，所以必须单独判断"""
# 当强袭状态为False时，直接返回False
if not self.onslaught:
return False
# 当强袭状态为激活时，则需要判断自己是否处于前台，或是退场的3秒以内。
# 若自己处于前台，则直接返回True
if self.dynamic.on_field:
return True
# 若自己处于后台，则需要判断退场时间
# 当自己退场时间小于等于3秒时，返回True
if self.dynamic.is_off_field_within(max_ticks=self.state_keep_tick):
return True
# 当自己退场时间大于3秒时，返回False
else:
return False
def besiege_active_check(self) -> tuple[bool, bool]:
"""
围杀状态是否生效：需要强袭状态和明攻状态同时生效，返回的是席德以及正兵的围杀状态，
围杀状态需要强袭状态和明攻状态同时生效，对于席德和正兵来说，围杀的生效判定条件不同。
对于席德来说，需要自身的强袭Buff处于生效，且正兵身上的明攻状态存在，就可以通过判定
对于正兵来说，需要自身的明攻Buff生效，且席德身上的强袭状态存在，就可以通过判定
"""
seed_besiege = self.onslaught_active and self.direct_strike
vanguard_besiege = self.direct_strike_active and self.onslaught
return seed_besiege, vanguard_besiege
@property
def besiege(self) -> bool:
"""围杀状态，当强袭状态和明攻状态同时为True时，为True"""
return self.onslaught and self.direct_strike
@property
def e_ex_repeat_limit_reached(self) -> bool:
"""强化E第一段的释放次数是否达到最大次数"""
if not self.dynamic.lasting_node.is_spamming:
return False
if self.dynamic.lasting_node.node.skill_tag != "1461_E_EX_1":
return False
result = self.dynamic.lasting_node.repeat_times == self.sesm.e_ex_max_repeat_times
return result
def special_resources(self, *args, **kwargs) -> None:
"""模拟Seed的特殊资源机制"""
assert self.sim_instance is not None
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
# 对输入的skill_node进行遍历
for node in skill_nodes:
# 更新能耗转化的钢能值
self.update_steel_charge_from_sp_cost(skill_node=node)
# 更新特殊状态
self.update_special_state(node)
if node.char_name == self.NAME:
# 更新强化E状态
self.sesm.update_ex_state(skill_node=node)
# SNA2和SNA3技能消耗钢能值
if node.skill_tag in ["1461_SNA_2", "1461_SNA_3"]:
self.update_steel_charge(
value=self.sna_steel_charge_cost * -1, update_origin=node.skill_tag
)
# Q技能获得钢能值
elif node.skill_tag == "1461_Q":
self.update_steel_charge(
value=self.Q_steel_charge_get, update_origin=node.skill_tag
)
if SEED_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【席德事件】席德释放了 {node.skill_tag} 获得了{self.Q_steel_charge_get}点钢能值"
)
elif node.skill_tag == "1461_SNA_1":
# SNA_1处理
active_generation_node_stack = self.sim_instance.preload.preload_data.personal_active_generation_node_stack[
1461
]
latest_active_generation_node = active_generation_node_stack.peek()
# 首先确认是否存在刚好结束的强化E第一段，因为衔接在强化E后自动释放的SNA_1是不会消耗快速释放标记的
e_ex_is_just_end = False
if latest_active_generation_node is not None:
if all(
[
latest_active_generation_node.skill_tag == "1461_E_EX_1",
latest_active_generation_node.end_tick == self.sim_instance.tick,
]
):
e_ex_is_just_end = True
if not e_ex_is_just_end:
if self.sna_quick_release:
self.sna_quick_release = False
else:
print(
"【席德测试】检测到位于强化E后自动衔接释放的SNA_1，本次释放不会消耗快速释放标记！"
)
@property
def steel_charge(self) -> float:
return self._steel_charge
@steel_charge.setter
def steel_charge(self, value: int | float) -> None:
assert self.sim_instance is not None
# 检查钢能值足够的上升沿（支持1画和0画的不同门槛）
threshold = self.sna_steel_charge_cost * 2
if self._steel_charge < threshold <= self._steel_charge + value:
# 在检测到钢能值足够的上升沿时，打开sna的快速释放标记。
self.sna_quick_release = True
# if SEED_REPORT:
# self.sim_instance.schedule_data.change_process_state()
# print(f"【席德事件】钢能值达到门槛({threshold}点)，开启SNA快速释放")
value = min(value, self.max_steel_charge)
self._steel_charge = value
def update_steel_charge(self, value: int | float, update_origin: str) -> None:
"""更新钢能值"""
if value < 0:
assert abs(value) <= self.steel_charge, (
f"{update_origin}企图消耗{abs(value):.2f}点钢能值，目前钢能值为{self.steel_charge:.2f}点，钢能值不足！"
)
self.steel_charge += value
@property
def steel_charge_enough(self) -> bool:
"""判断钢能值是否足够"""
result = self.steel_charge >= self.sna_steel_charge_cost * 2
return result
def update_special_resource(self, skill_node: "SkillNode"):
"""
从命中中更新钢能值，该函数的调用时机为命中后，
所以不在Character的special_resource内进行更新，而是在Schedule阶段调用。
"""
if skill_node.char_name != self.NAME:
return
if skill_node.labels is None:
return
if "steel_charge" in skill_node.labels:
total_value = skill_node.labels["steel_charge"]
assert isinstance(total_value, int | float)
value = total_value / skill_node.skill.hit_times
self.update_steel_charge(value=value, update_origin=skill_node.skill_tag)
def update_steel_charge_from_sp_cost(self, skill_node: "SkillNode"):
"""
因技能能耗而更新钢能值，但注意，只有正兵和席德本身的能耗才能转化为钢能值
"""
assert self.sim_instance is not None
# 筛选出正兵和席德本身的技能
if self.vanguard is not None:
if skill_node.char_name not in [self.NAME, self.vanguard.NAME]:
return
else:
if skill_node.char_name not in [self.NAME]:
return
sp_consume = skill_node.skill.sp_consume
if sp_consume == 0:
return
value = sp_consume * self.sp_to_steel_ratio
self.update_steel_charge(value=value, update_origin=f"{skill_node.skill_tag}能耗转化")
if SEED_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【席德事件】{skill_node.skill_tag}消耗了{sp_consume:.2f}点能量，转化为{value:.2f}点钢能值"
)
def update_special_state(self, skill_node: "SkillNode"):
"""更新席德的特殊状态，这个函数有两个任务：
1、在正兵释放强化E时，开启强袭状态；
2、在席德释放强化E时，开启明攻状态；"""
if skill_node.skill.trigger_buff_level != 2:
return
if self.vanguard is None:
return
if skill_node.char_name == self.NAME:
self.direct_strike = True
else:
if skill_node.char_name == self.vanguard.NAME:
self.onslaught = True
def POST_INIT_DATA(self, sim_instance: "Simulator"):
"""在初始化阶段，席德需要通过基础攻击力来确认“正兵”人选，只有强攻类型的角色才能成为正兵"""
atk_box = []
vanguard = None
for char_obj in sim_instance.char_data.char_obj_list:
if not char_obj.specialty == "强攻":
continue
char_atk_outside = char_obj.statement.ATK
atk_box.append(char_atk_outside)
if char_atk_outside == max(atk_box):
vanguard = char_obj
else:
self.vanguard = vanguard
assert self.vanguard is not None
# 席德无法指定正兵为自己
if self.vanguard.NAME == self.NAME:
self.vanguard = None
else:
if SEED_REPORT:
sim_instance.schedule_data.change_process_state()
print(f"【席德事件】本次模拟中，席德找到的正兵为：{self.vanguard.NAME}！")
self.onslaught = True
self.direct_strike = True
if self.vanguard is None:
if SEED_REPORT:
sim_instance.schedule_data.change_process_state()
print("【席德事件】注意！席德并未在当前队伍里找到正兵！")
def reset_myself(self):
# 重置能量、喧响值
self.sp: float = 40.0
self.decibel: float = 1000.0
# 重置动态属性
self.dynamic.reset()
# 重置特殊状态
self._onslaught = False
self._onslaught_active_tick = 0
self._direct_strike = False
self._direct_strike_active_tick = 0
def personal_action_replace_strategy(self, action: str):
"""
席德的个人动作替换策略，根据强化E连段情况的不同，将传入的动作指令替换成不同的skill_tag
"""
return self.sesm.action_replacement_handler(action=action)
def get_resources(self, *args, **kwargs) -> tuple[str | None, int | float | None]:
return "钢能值", self.steel_charge
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
from .ExStateManager import SeedEXState
return {
"钢能值足够": self.steel_charge_enough,
"sna快速释放": self.sna_quick_release,
"强袭状态": self.onslaught,
"明攻状态": self.direct_strike,
"围杀状态": self.besiege,
"强袭状态生效": self.onslaught_active,
"明攻状态生效": self.direct_strike_active,
"正兵": self.vanguard.NAME if self.vanguard else None,
"强化E达到最大次数": self.e_ex_repeat_limit_reached,
"强化E连续释放": self.sesm.e_ex_state in [SeedEXState.LOOPING, SeedEXState.FIRST_CAST],
}
================================================
FILE: zsim/sim_progress/Character/Soldier0_Anby.py
================================================
from zsim.sim_progress.Preload import SkillNode
from .character import Character
from .utils.filters import _skill_node_filter
class Soldier0_Anby(Character):
"""大安比的银星机制"""
# TODO：把银星的逻辑写在Char里面是偷懒的做法！！！这本应该是一个debuff
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.silver_star: float = 0.0 # 银星
self.white_thunder_update_tick: int = 0 # 白雷更新时间
self.continuing_white_thunder_counter: int = 0 # 连续白雷的计数器
self.white_thunder_answer: bool = False # 白雷的触发响应器
self.thunder_smite_answer: bool = False # 雷殛的触发响应器
self.continuing_e: bool = True # E连击的触发响应器
self.c1_answer: bool = False # 1画的强化E白雷的触发响应器
self.c1_counter: int = 0 # 1画的额外白雷结算次数。
self.c2_counter: int = 0 # 2画的层数计数器
self.c6_counter: int = 0 # 6画计数器
self.c6_answer: bool = False # 6画的触发响应器
self.silver_star_basic_cost = 33.333333 # 单E的银星基本消耗
self.max_silver_star: float = 100.1 # 银星上限
self.silver_star_gain_dict: dict[str, float] = {
"1381_NA_1": 4.6875,
"1381_NA_2": 7.53472222,
"1381_NA_3": 15.12152778,
"1381_NA_4": 2.34375,
"1381_NA_5": 18.75,
"1381_E_B": 11.11,
"1381_E_EX": 100.1,
"1381_CA": 50.1,
"1381_QTE": 21.09375,
"1381_Q": 100.1,
"1381_BH_Aid": 6.25,
"1381_Assault_Aid": 6.25,
}
@property
def full(self):
if self.silver_star >= self.max_silver_star:
return True
else:
return False
def special_resources(self, *args, **kwargs) -> None:
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
tick = kwargs.get("tick", 0)
for nodes in skill_nodes:
_skill_tag = nodes.skill_tag
# 1、筛去不是本角色的技能
if "1381" not in _skill_tag:
continue
# 2、处理传入的白雷、雷殛、6命
if _skill_tag == "1381_CoAttack":
self.__white_thunder_processor(tick)
elif _skill_tag == "1381_E_Aid":
self.__thunder_smite_processor()
elif _skill_tag == "1381_Cinema_6":
self.__cinema_6_filter()
# 3、处理消层的E
elif _skill_tag == "1381_E_A":
self.__azure_flash_processor()
# 4、处理其他技能——叠印记
else:
self.continuing_e = False
if _skill_tag == "1381_E_EX" and self.cinema >= 1:
self.c1_answer = True
if _skill_tag == "1381_Q" and self.cinema >= 2:
self.c2_counter += 6
if self.c2_counter > 6:
self.c2_counter = 6
self.silver_star += self.silver_star_gain_dict.get(nodes.skill_tag, 0.0)
# print(f'{_skill_tag}使银星层数增长了，当前层数为{self.silver_star:.2f}')
"""最大值检查"""
if self.silver_star > self.max_silver_star:
self.silver_star = self.max_silver_star
def __azure_flash_processor(self):
"""处理层数逻辑"""
self.__check_myself()
if self.full:
self.continuing_e = True
"""在解锁2画，并且有预存层数的时候，优先使用层数，并且照常激活白雷。"""
if self.cinema >= 2 and self.c2_counter > 0:
self.c2_counter -= 1
else:
self.silver_star -= self.silver_star_basic_cost
self.white_thunder_answer = True
if self.silver_star < 0:
print("银星扣过头了！")
self.silver_star = 0
def __thunder_smite_processor(self):
"""处理雷殛的函数。"""
if not self.thunder_smite_answer:
print("非法雷殛！在雷殛响应状态未开启的情况下，触发了雷殛！")
self.thunder_smite_answer = False
def __white_thunder_processor(self, tick):
"""针对白雷进行更新，包括来源判断、计数器更新、以及响应器更新。"""
if not self.white_thunder_answer and not self.c1_answer:
print(
"非法白雷！在零号·安比白雷响应状态未开启、1画的强化E状态也未开启 的情况下，触发了白雷！"
)
if self.cinema >= 1 and self.c1_answer:
self.c1_filter()
else:
self.c0_filter(tick)
# 白雷计数器层数更新结束后，对雷殛进行更新。
self.c6_updater()
self.__thunder_smite_active()
def c6_updater(self):
"""
更新6画逻辑
从文字描述上看，6画的添加行为应该属于协同攻击「白雷」的后置，但如果利用白雷的follow_up来进行c6的添加，那么就会导致以下问题：
c6添加的时间点为白雷6 结束时，在这个Tick，白雷6会在Preload阶段的ForceAddEngine中被识别到结束信号，
此时，ForceAddEngine会尝试读取白雷6的follow up以及对应的force_add_APL，
由于ForceAddEngine每个Tick只能进行一次ForceAdd添加，这就会导致C6的协同攻击和雷殛相互抢队，谁排在前面，就执行谁。
所以，在之前的debug中，我总能观察到C6的协同攻击被大幅度延后，以至于C6计数器都出现了问题。
在后来的更新中，我将C6等价为雷殛的后置技能，从而摆脱了抢队问题。
经验：同一个技能的多个follow up必须是互斥的，如果存在一个tick通过多个follow up 判定的可能，就要做特殊处理。否则一定会因为抢队出问题。
"""
if self.cinema == 6:
self.c6_counter += 1
if self.c6_counter >= 6:
self.c6_answer = True
self.c6_counter = 0
def c0_filter(self, tick):
"""通用逻辑"""
self.white_thunder_answer = False
"""给了3帧的时间宽限"""
if self.white_thunder_update_tick == 0:
self.continuing_white_thunder_counter += 1
elif tick - self.white_thunder_update_tick <= 30:
self.continuing_white_thunder_counter += 1
else:
"""超时则清空——这个分支就是“连续”的体现。"""
self.continuing_white_thunder_counter = 1
self.white_thunder_update_tick = tick
def c1_filter(self):
"""解锁1画时，检测到c1_answer开启时，无视白雷响应器状态直接更新白雷计数器，计数器到3，把1画的强化响应器关闭。"""
self.continuing_white_thunder_counter += 1
self.c1_counter += 1
if self.c1_counter >= 3:
self.c1_answer = False
self.c1_counter = 0
def __thunder_smite_active(self):
"""在白雷计数器更新后，尝试对雷殛激活状态进行更新。"""
if self.continuing_white_thunder_counter >= 3:
if self.thunder_smite_answer:
print("在未结算上一次雷殛的情况下，再次触发了雷殛！")
self.thunder_smite_answer = True
self.continuing_white_thunder_counter = 0
def __check_myself(self):
"""自检"""
if self.silver_star < self.silver_star_basic_cost and self.c2_counter == 0:
print("当前可用的银星层数不够，传入的操作企图触发白雷，请检查APL！")
if self.white_thunder_answer:
print("白雷响应状态仍保持开启的情况下，再次企图触发了白雷！ 当前存在未结算的白雷！！")
def __cinema_6_filter(self):
if self.cinema != 6:
raise ValueError("在未激活6画的情况下，触发了6画的追加攻击！")
if not self.c6_answer:
print("在6画的追加攻击响应器未开启的情况下，触发了6画的追加攻击！")
self.c6_answer = False
def get_resources(self) -> tuple[str | None, int | float | bool | None]:
return (
"银星层数",
self.silver_star / self.silver_star_basic_cost + self.c2_counter,
)
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {
"白雷": self.white_thunder_answer,
"雷殛": self.thunder_smite_answer,
"6画状态": self.c6_answer,
"1画状态": self.c1_answer,
"白雷连击次数": self.continuing_white_thunder_counter,
"E连击": self.continuing_e,
"6画_白雷次数": self.c6_counter,
"1画_白雷次数": self.c1_counter,
"2画_电鸣": self.c2_counter,
"满层": self.full,
}
================================================
FILE: zsim/sim_progress/Character/Soldier11.py
================================================
from zsim.sim_progress.Preload import SkillNode
from .character import Character
from .utils.filters import _skill_node_filter
class Soldier11(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.fire_suppression: int = 0 # 强制的火力镇压
self.settle_tick: int | None = None
def special_resources(self, *args, **kwargs) -> None:
"""模拟11号的火力镇压机制"""
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
assert self.sim_instance is not None
tick: int = self.sim_instance.tick
for node in skill_nodes:
if self.settle_tick is not None:
# 超时重置
if tick - self.settle_tick >= 480:
self.fire_suppression = 0
self.settle_tick = None
# 过滤非11号技能
if "1041" not in node.skill_tag:
continue
# 获取层数逻辑
if node.skill_tag in ["1041_E_EX", "1041_QTE", "1041_Q"]:
self.fire_suppression = 8
self.settle_tick = tick
# 消耗层数逻辑
if "SNA" in node.skill_tag and self.fire_suppression > 0:
self.fire_suppression -= 1
def get_resources(self, *args, **kwargs) -> tuple[str | None, int | float | None]:
return "火力镇压", self.fire_suppression
================================================
FILE: zsim/sim_progress/Character/Soukaku.py
================================================
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Report import report_to_log
from .character import Character
from .utils.filters import _skill_node_filter
class Soukaku(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.vortex: int = 0 # 涡流初始0点
def special_resources(self, *args, **kwargs) -> None:
"""模拟苍角的涡流机制"""
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
# 对输入的skill_node进行遍历
for node in skill_nodes:
if "1131" not in node.skill_tag:
continue
if self.vortex <= 3:
if node.skill_tag in [
"1131_E_EX_1",
"1131_E_EX_2",
"1131_E_EX_3",
"1131_QTE",
]:
self.vortex += 1
report_to_log(f"[Character] 苍角的涡流被更新为 {self.vortex}")
elif node.skill_tag == "1131_Q":
self.vortex = 3
report_to_log(f"[Character] 苍角的涡流被更新为 {self.vortex}")
# 这里不能 elif
if self.vortex >= 3:
if node.skill_tag in ["1131_E_EX_A"]:
"""
在20241227的更新中，由于APL中补全了展旗的逻辑，
现在展旗会正确衔接了，具体会触发衔接的场合有：
1、能量不够（<30）的1、2段强化E
2、QTE
3、Q
"""
self.vortex = 0
# BuffAddStrategy('Buff-角色-苍角-核心被动-2')
report_to_log(f"[Character] 苍角的涡流被更新为 {self.vortex}")
def get_resources(self, *args, **kwargs) -> tuple[str | None, int | float | None]:
return "涡流", self.vortex
================================================
FILE: zsim/sim_progress/Character/Trigger/AfterShockManager.py
================================================
from .TriggerCoordinatedSupportTrigger import CoordinatedSupportManager
class AfterShock:
"""协同攻击基类"""
def __init__(self, skill_tag: str, cd: int, mode: int = 0):
self.update_tick = 0
self.cd = cd
self.active_result = skill_tag
if mode == 0:
self.complex_cd_manager = None
else:
self.complex_cd_manager = self.ComplexCDManager()
def is_ready(self, skill_node, tick: int):
# TODO：先写一个临时的
if self.complex_cd_manager is None:
if self.update_tick == 0:
return True
if tick - self.update_tick >= self.cd:
return True
return False
else:
return self.complex_cd_manager.is_available(skill_node, tick)
def after_shock_happend(self, tick: int):
"""抛出aftershock的skill_tag，并且更新自身信息"""
self.update_tick = tick
return self.active_result
class ComplexCDManager:
"""这是强化协同攻击的复杂CD管理器"""
def __init__(self):
self.cdm_e = BasicCDManager()
self.cdm_q = BasicCDManager()
self.cdm_aid = BasicCDManager()
self.cdm_map = {2: self.cdm_e, 6: self.cdm_q, 9: self.cdm_aid}
def is_available(self, skill_node, tick: int) -> bool:
"""整个CD管理器的对外接口，用来更新、判断此次触发信号能否成功激发一次协同攻击。"""
cdm = self.cdm_map.get(skill_node.skill.trigger_buff_level, None)
if cdm is None:
raise ValueError("传入的skill_node与complex_cd_manager不匹配")
__available_result = cdm.update(tick)
return __available_result
class BasicCDManager:
def __init__(self):
self.cd = 1200
self.max_count = 2
self.count = 2
self.start_tick = 0
self.refresh_tick = 0
self.active = False
def refresh_myself(self, tick: int):
self.count = self.max_count
self.active = True
self.start_tick = tick
self.refresh_tick = tick + self.cd
def start_myself(self, tick: int):
self.refresh_myself(tick)
self.count -= 1
def update(self, tick: int) -> bool:
"""根据扳机的强化协同攻击的CD管理机制，写的等效逻辑。"""
if self.count == 2:
self.start_myself(tick)
return True
elif self.count == 1:
if tick >= self.refresh_tick:
self.start_myself(tick)
return True
else:
self.count -= 1
return True
elif self.count == 0:
if tick >= self.refresh_tick:
self.start_myself(tick)
return True
else:
pass
# print(
# "由于层数耗尽且尚未到达刷新时间，扳机并未成功触发本次强化协同！！"
# )
return False
class AfterShockManager:
"""协同攻击管理器， 服务于角色——扳机"""
def __init__(self, char_instance):
self.char = char_instance
normal_after_shock_cd = 180 if self.char.cinema < 1 else 120
self.normal_after_shock = AfterShock("1361_CoAttack_A", normal_after_shock_cd, mode=0)
self.strong_after_shock = AfterShock("1361_CoAttack_1", 300, mode=1)
self.coordinated_support_manager = CoordinatedSupportManager()
def spawn_after_shock(self, tick: int, loading_mission) -> str | None:
"""
根据传入的skill_node抛出对应的协同攻击，并且更新自身数据；
这个函数接口是为Buff阶段服务的！请不要在Preload以及char的special_resource阶段调用本函数
"""
if not self.char.is_available(tick):
return None
skill_node = loading_mission.mission_node
"""优先判断强协同攻击: 只有重击的最后一跳才能触发！"""
if tick - 1 < loading_mission.get_last_hit() <= tick and skill_node.skill.heavy_attack:
if skill_node.skill.trigger_buff_level in [2, 6, 9]:
if self.strong_after_shock.is_ready(skill_node, tick):
if self.char.get_resources()[1] >= 5:
if self.strong_after_shock.complex_cd_manager.is_available(
skill_node, tick
):
strong_after_shock_tag = self.strong_after_shock.after_shock_happend(
tick
)
self.char.update_purge(strong_after_shock_tag)
return strong_after_shock_tag
# else:
# print(f'决意值为{self.char.get_resources()[1]}，无法触发强化协同攻击！')
"""其次判断协战状态的免费协同"""
free_after_shock = self.coordinated_support_manager.spawn_after_shock(tick)
if free_after_shock is not None:
return free_after_shock
"""最后，判断消耗决意值的普通协同"""
if skill_node.skill.trigger_buff_level in [0, 1, 3, 4, 7]:
if self.normal_after_shock.is_ready(skill_node, tick):
if self.char.get_resources()[1] >= 3:
normal_after_shock_tag = self.normal_after_shock.after_shock_happend(tick)
self.char.update_purge(normal_after_shock_tag)
return normal_after_shock_tag
# else:
# print(f'决意值为{self.char.get_resources()[1]}，无法触发普通协同攻击！')
return None
================================================
FILE: zsim/sim_progress/Character/Trigger/TriggerCoordinatedSupportTrigger.py
================================================
class CoordinatedSupportManager:
"""协战状态管理器"""
def __init__(self):
self.coordinated_support = False
self.update_tick = 0
self.end_tick = 0
self.max_duration = 1200
self.max_count = 10
self.after_shock_tag = "1361_CoAttack_A"
self.count = 0
self.update_count_box = {2: 4, 6: 6}
self.update_tick_box = {2: 480, 6: 720}
def update_myself(self, tick: int, skill_node):
"""传入skill_node，更新自身状态，该函数只负责刷新协战状态，不负责层数减少。"""
tbl = skill_node.skill.trigger_buff_level
if tbl in [2, 6]:
self.refresh_myself(tbl, tick)
def refresh_myself(self, tbl, tick):
"""更新协战状态的函数
关于协战状态的结束时间（end_tick）的更新逻辑，这个比较复杂。
由于协战状态的池子中的剩余时间是可以叠加的，但又存在最大值。
如果用最无脑的写法，那应该写一个函数，每个tick更新一次所谓的“剩余时间”，但是这样做实在是太浪费计算资源了。
所以这里考虑了一个等效的算法，这个算法会在每次激活协战状态时，无脑更新start_tick和end_tick，
其中，end_tick的更新逻辑较为复杂，但是无论是哪一种情况，都可以表达为：
min(max(原结束时间 - 当期时间, 0) + 新增加的时间, 当前时间 + 最大持续时间) + 当前时间
图形理解：
情况1：新增时间∆t并未使Buff时间溢出
|---------|---------------|------------------------|-------------|
情况说明： tick_now 老end_tick ∆t 新end_tick 最大时间
情况2：新增时间∆t使得时间溢出
|---------|---------------|------------------------|-------------|
情况说明： tick_now 老end_tick ∆t 最大时间 新end_tick
情况3：新增发生前，状态早已结束
|---------|---------------|------------------------|---------------------------|
情况说明： 老end_tick tick_now ∆t 新end_tick 最大时间
纵观全部的触发情况，无外乎上面三种。而无论哪一种情况，公式都可以准确算出新end_tick的位置。"""
self.coordinated_support = True
self.update_tick = tick
end_tick_new = (
min(
max(self.end_tick - tick, 0) + self.update_tick_box[tbl],
tick + self.max_duration,
)
+ tick
)
self.end_tick = end_tick_new
self.count += self.update_count_box[tbl]
self.count = min(self.count, self.max_count)
# print(f'协战状态更新！当前层数：{self.count}，结束时间{self.end_tick}， 当前剩余时间：{self.end_tick - tick}')
def is_active(self, tick: int):
"""检查自身Buff状态是否存在"""
if self.end_tick > tick:
if self.count > 0:
return True
return False
def end(self, tick: int):
"""Buff结束"""
# print(f'协战状态结束了，当前层数：{self.count}，当前剩余时间：{self.end_tick - tick}')
self.coordinated_support = False
self.count = 0
self.update_tick = tick
def spawn_after_shock(self, tick: int) -> str | None:
"""生成协同攻击的函数"""
if self.is_active(tick):
self.count -= 1
# print(f'协战状态触发了一次协同攻击，剩余层数：{self.count}，当前剩余时间：{self.end_tick - tick}')
if self.count <= 0:
self.end(tick)
return self.after_shock_tag
return None
================================================
FILE: zsim/sim_progress/Character/Trigger/__init__.py
================================================
from typing import TYPE_CHECKING
from ..character import Character
from ..utils.filters import _skill_node_filter
from .AfterShockManager import AfterShockManager
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class Trigger(Character):
"""扳机的特殊资源"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.after_shock_manager = AfterShockManager(self)
self.purge = 0 # 决意值
self.max_purge = 100 if self.cinema < 1 else 125
self.purge_gain_ratio = 1 if self.cinema < 1 else 1.25
self.sniper_stance = False # 狙击姿态
def special_resources(self, *args, **kwargs) -> None:
"""
这个函数在preload阶段被调用，主要用于更新协战状态、以及自身的决意值；
而这里的更新主要是状态的刷新、持续时间的增加以及层数的增加，
至于抛出协同攻击、层数减少以及决意值消耗，则在Buff阶段进行执行，这边只要留好接口即可；
接口：应该是char.spawn_after_shock，对内调用self.after_shock_manager的相应方法。
"""
skill_nodes: list["SkillNode"] = _skill_node_filter(*args, **kwargs)
tick = kwargs.get("tick", 0)
for nodes in skill_nodes:
_skill_tag = nodes.skill_tag
# 1、筛去不是本角色的技能
if "1361" not in _skill_tag:
if nodes.active_generation:
self.sniper_stance = False
continue
# 2、处理传入的强化E、Q，更新协战状态
self.after_shock_manager.coordinated_support_manager.update_myself(tick, nodes)
if nodes.skill_tag in ["1361_SNA_1", "1361_SNA_2"]:
if not self.sniper_stance:
raise ValueError(f"在非狙击姿态的情况下传入了{nodes.skill_tag}")
purge_delta = 25 * self.purge_gain_ratio
self.purge += purge_delta
if self.purge > self.max_purge:
self.purge = self.max_purge
elif nodes.skill_tag == "1361_SNA_0":
if self.sniper_stance:
raise ValueError("在狙击姿态已经开启的情况下传入了1361_SNA_0")
self.sniper_stance = True
elif nodes.skill_tag == "1361_SNA_3":
if not self.sniper_stance:
raise ValueError("在狙击姿态已经关闭的情况下传入了1361_SNA_3")
self.sniper_stance = False
def update_purge(self, skill_tag):
"""在Buff阶段更新决意值的函数！"""
if skill_tag == "1361_CoAttack_A":
if self.purge < 3:
print(f"现有决意值不足以触发{skill_tag}！请检查函数逻辑！")
self.purge = self.purge - 3 if self.purge >= 3 else 0
elif skill_tag == "1361_CoAttack_1":
if self.purge < 5:
print(f"现有决意值不足以触发{skill_tag}！请检查函数逻辑！")
self.purge = self.purge - 5 if self.purge >= 5 else 0
def get_resources(self) -> tuple[str | None, int | float | bool | None]:
return "决意值", self.purge
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {"狙击姿态": self.sniper_stance}
================================================
FILE: zsim/sim_progress/Character/Vivian/FeatherManager.py
================================================
from zsim.define import VIVIAN_REPORT
from zsim.sim_progress.Preload import SkillNode
from ..character import Character
class FeatherManager:
"""薇薇安的羽毛管理器，飞羽、护羽存储、转化、消耗。"""
def __init__(self, char_instance: Character):
self.char = char_instance
self.flight_feather = 2 # 飞羽，进场初始化为4层
self.guard_feather = 0 if self.char.cinema < 4 else 5 # 护羽，初始化为0层
self.feather_max_count = 5 # 最大飞羽/护羽层数，默认为6层
self.co_attack_index = "1331_CoAttack_A"
self.c1_counter = 0 # 1 画计数器
def update_myself(self, skill_node: SkillNode = None, c6_signal: bool = None):
"""
用来更新羽毛的方法，被薇薇安的羽毛触发器调用，
该函数内部没有任何类型判断，所有的判断全部交给羽毛触发器的xjudge
"""
if skill_node is None and c6_signal is None:
raise ValueError(
"薇薇安羽毛管理器的update_myself函数必须传入skill_node或c6_singal参数中的一个！"
)
if c6_signal or skill_node.skill_tag == "1331_SNA_2":
self.trans_feather()
else:
self.gain_feather(skill_node)
def trans_feather(self):
"""将现有的飞羽全部转化成护羽：注意，飞羽转化为护羽的时间点为SNA_2的最后一跳，所以这里不能走特殊资源，只能从触发器走。"""
trans_count = self.flight_feather
self.guard_feather = min(self.guard_feather + trans_count, self.feather_max_count)
self.flight_feather = 0
if VIVIAN_REPORT:
self.char.sim_instance.schedule_data.change_process_state()
print(
f"羽毛管理器：羽毛转化！当前的护羽、飞羽数量为：{self.guard_feather, self.flight_feather}"
)
def gain_feather(self, skill_node: SkillNode):
"""
获得飞羽，飞羽的获得结算大多为技能的最后一跳，所以也需要从触发器走。
该函数内部没有任何类型判断，所有的判断全部交给羽毛触发器的xjudge
"""
if not skill_node.skill.labels:
return
if "flight_feather" not in skill_node.skill.labels.keys():
return
flight_feather_count = skill_node.labels["flight_feather"]
c6_feather = skill_node.labels.get("c6_feather", 0)
if self.char.cinema == 6:
flight_feather_count += c6_feather
self.flight_feather = min(
self.flight_feather + flight_feather_count, self.feather_max_count
)
if VIVIAN_REPORT:
self.char.sim_instance.schedule_data.change_process_state()
print(
f"羽毛管理器：获得{flight_feather_count}点羽毛！当前护、飞羽数量为：{self.guard_feather, self.flight_feather}"
)
def spawn_coattack(self) -> str | None:
"""尝试生成一次生花"""
if self.guard_feather > 0:
self.guard_feather -= 1
if self.char.cinema >= 1:
self.c1_counter += 1
if self.c1_counter >= 4:
self.flight_feather = min(self.flight_feather + 1, self.feather_max_count)
self.c1_counter -= 4
if VIVIAN_REPORT:
self.char.sim_instance.schedule_data.change_process_state()
print(
f"羽毛管理器：落羽生花完成结算！当前的护羽、飞羽数量为：{self.guard_feather, self.flight_feather}"
)
return self.co_attack_index
else:
return None
================================================
FILE: zsim/sim_progress/Character/Vivian/__init__.py
================================================
from typing import TYPE_CHECKING
from ..character import Character
from ..utils.filters import _skill_node_filter
from .FeatherManager import FeatherManager
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class Vivian(Character):
"""薇薇安的特殊资源模块"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.feather_manager = FeatherManager(self) # 羽毛管理器（飞羽、护羽的获取、切换）
self.state_level = 0 # 状态等级，0是无状态，1是开伞，2是飘浮
@property
def noblewoman_state(self) -> bool: # 判定当前是否为开伞状态（淑女仪态）
return self.state_level == 1
@property
def fluttering_frock_state(self) -> bool: # 判定当前是否为飘浮状态（裙裾浮游）
return self.state_level == 2
def __check_node(self, skill_node: "SkillNode") -> None:
"""检查传入的SkillNode，是否符合当前的状态。"""
skill_tag = skill_node.skill_tag
if skill_tag not in ["1331_SNA_0", "1331_SNA_1", "1331_SNA_2"]:
return
if skill_tag == "1331_SNA_0":
if not self.fluttering_frock_state:
raise ValueError(
f"薇薇安的SNA_0的作用是从飘浮状态退回开伞状态，而当前状态等级为{self.state_level}，无法释放{skill_tag}"
)
elif skill_tag == "1331_SNA_1":
if not self.noblewoman_state:
raise ValueError(
f"薇薇安的SNA_1只能在开伞状态下释放，而当前状态等级为{self.state_level}，无法释放{skill_tag}"
)
elif skill_tag == "1331_SNA_2":
if not self.fluttering_frock_state:
raise ValueError(
f"薇薇安的SNA_2只能在飘浮状态下释放，而当前状态等级为{self.state_level}，无法释放{skill_tag}"
)
def special_resources(self, *args, **kwargs) -> None:
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
if "1331" not in node.skill_tag:
continue
self.__check_node(node)
if node.skill_tag in ["1331_SNA_0", "1331_BH_Aid", "1331_NA_4"]:
# 进入开伞状态
self.state_level = 1
elif node.skill_tag == "1331_SNA_2":
# 退回最初状态
self.state_level = 0
elif node.skill_tag in [
"1331_SNA_1",
"1331_E_EX",
"1331_CA",
"1331_QTE",
"1331_Q",
"1331_Assault_Aid",
]:
# 直接飘浮
self.state_level = 2
else:
return
def get_resources(self) -> tuple[str, int]:
return "护羽", self.feather_manager.guard_feather
def get_special_stats(self, *args, **kwargs) -> dict[str, int | float | bool]:
return {
"护羽数量": self.feather_manager.guard_feather,
"飞羽数量": self.feather_manager.flight_feather,
"裙裾浮游": self.fluttering_frock_state,
"淑女仪态": self.noblewoman_state,
}
================================================
FILE: zsim/sim_progress/Character/Yanagi/StanceManager.py
================================================
from zsim.sim_progress.Buff import find_tick
from zsim.sim_progress.Preload import SkillNode
class Shinrabanshou:
def __init__(self, cinema: int, char_instance):
self.max_duration = 900 if cinema < 6 else 1800
self.update_tick = 0
self.char = char_instance
def statement(self, tick: int):
"""查询 柳的森罗万象状态的方法"""
if self.update_tick == 0:
return False
if tick - self.update_tick >= self.max_duration:
return False
return True
@property
def active(self):
"""更新森罗万象的时间！"""
tick = find_tick(sim_instance=self.char.sim_instance)
return tick < self.update_tick + self.max_duration
class StanceManager:
"""柳的架势管理器"""
def __init__(self, char_instance):
self.char = char_instance
self.stance_jougen = True # 上弦状态，初始化时就是上弦
self.stance_kagen = False # 下弦状态
self.last_update_node = None # 上次导致架势管理器的数据发生更新的skill_node
self.shinrabanshou = Shinrabanshou(self.char.cinema, self.char) # 森罗万象管理器
self.ex_chain = False # 突刺连段状态，也可以理解为'是否正在释放强化E'
self.stance_changing_buff_index = "Buff-角色-柳-额外能力-积蓄效率"
def update_myself(self, skill_node: SkillNode):
"""接收skill_node，并且判断自身架势是否要改变；"""
skill_tag = skill_node.skill_tag
"""首先筛掉不是自己的skill_node"""
if "1221" not in skill_tag:
return
"""若传入的skill_node不能触发任何架势直接返回！"""
if skill_tag not in [
"1221_E",
"1221_E_A",
"1221_QTE",
"1221_Assault_Aid",
"1221_E_EX_1",
"1221_E_EX_2",
]:
return
"""若检测到强化E 突刺攻击，则需要分类讨论"""
if skill_tag == "1221_E_EX_1":
if (
self.last_update_node is not None
and self.last_update_node.skill_tag == "1221_E_EX_1"
):
"""当检测到上一个使架势管理器发生更新的技能是穿刺攻击时，直接返回"""
if not self.ex_chain:
raise ValueError(
"检测到中间段强化E的突刺攻击时，架势管理器的ex_chain未处于打开状态！"
)
return
else:
"""其余情况，穿刺攻击的上一个技能都不会是穿刺攻击，所以可以放行。改变架势 + 启动森罗万象"""
if self.ex_chain:
# raise ValueError(f'检测到首段强化E的突刺攻击时，架势管理器的ex_chain正处于打开状态！')
print("检测到首段强化E的突刺攻击时，架势管理器的ex_chain正处于打开状态！")
self.ex_chain = True
# print(f'强化E连段开始')
tick = find_tick(sim_instance=self.char.sim_instance)
self.shinrabanshou.update_tick = tick
self.last_update_node = skill_node
self.change_stance()
elif skill_tag == "1221_E_EX_2":
"""检测到强化E的下落攻击分支"""
if not self.ex_chain:
raise ValueError(
"检测到强化E下落攻击传入，但是架势管理器的ex_chain未处于打开状态！"
)
self.ex_chain = False
self.last_update_node = skill_node
# print(f'强化E连段结束')
else:
"""其余情况全部都执行一次架势切换"""
self.change_stance()
self.last_update_node = skill_node
def change_stance(self):
"""更新架势"""
if self.stance_jougen == self.stance_kagen:
raise ValueError("上弦、下弦状态不能同时为True或False！")
if self.stance_jougen:
self.stance_jougen = False
self.stance_kagen = True
else:
self.stance_jougen = True
self.stance_kagen = False
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
buff_add_strategy(self.stance_changing_buff_index, sim_instance=self.char.sim_instance)
@property
def stance_now(self):
"""返回当前的架势状态，True是上弦，False是下弦"""
if self.stance_jougen:
return True
elif self.stance_kagen:
return False
else:
raise ValueError("上弦、下弦状态不能同时为True或False！")
================================================
FILE: zsim/sim_progress/Character/Yanagi/__init__.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import NewAnomaly
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
from zsim.sim_progress.Preload import SkillNode
from ..character import Character
from ..utils.filters import (
_anomaly_filter,
_skill_node_filter,
)
from .StanceManager import StanceManager
if TYPE_CHECKING:
pass
class Yanagi(Character):
"""柳的特殊资源系统"""
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.stance_manager = StanceManager(self)
self.cinme_1_buff_index = "Buff-角色-柳-1画-洞悉"
self.cinema_4_buff_index = "Buff-角色-柳-4画-识破"
def special_resources(self, *args, **kwargs) -> None:
skill_nodes: list["SkillNode"] = _skill_node_filter(*args, **kwargs)
anomalies: list[NewAnomaly] = _anomaly_filter(*args, **kwargs)
# tick = kwargs.get('tick', 0)
for nodes in skill_nodes:
self.stance_manager.update_myself(nodes)
if self.cinema >= 1 and anomalies:
if self.sim_instance is not None:
buff_add_strategy(self.cinme_1_buff_index, sim_instance=self.sim_instance)
if self.cinema >= 4:
for _anomaly in anomalies:
if isinstance(_anomaly.activate_by, SkillNode):
if str(self.CID) in _anomaly.activate_by.skill_tag:
if self.sim_instance is not None:
buff_add_strategy(
self.cinema_4_buff_index, sim_instance=self.sim_instance
)
break
def update_sp_and_decibel(self, *args, **kwargs):
"""自然更新能量和喧响的方法"""
# Preload Skill
skill_nodes = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
# SP
if node.char_name == self.NAME:
if node.skill_tag == "1221_E_EX_1" and self.cinema == 6:
sp_consume = node.skill.sp_consume / 2
else:
sp_consume = node.skill.sp_consume
sp_threshold = node.skill.sp_threshold
sp_recovery = node.skill.sp_recovery
if self.sp < sp_threshold:
print(
f"{node.skill_tag}需要{sp_threshold:.2f}点能量，目前{self.NAME}仅有{self.sp:.2f}点，需求无法满足，请检查技能树"
)
sp_change = sp_recovery - sp_consume
self.update_sp(sp_change)
# Decibel
self.process_single_node_decibel(node)
# SP recovery over time
self.update_sp_overtime(args, kwargs)
def get_resources(self) -> tuple[str | None, int | float | bool | None]:
"""柳的get_resource不返回内容！因为柳没有特殊资源，只有特殊状态"""
return None, None
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
return {
"当前架势": self.stance_manager.stance_now,
"森罗万象状态": self.stance_manager.shinrabanshou.active,
}
================================================
FILE: zsim/sim_progress/Character/Yixuan/AdrenalineEventClass.py
================================================
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
from zsim.define import YIXUAN_REPORT
if TYPE_CHECKING:
from zsim.sim_progress.Character.Yixuan import Yixuan
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
class BaseAdrenalineEvent(ABC):
"""管理单个闪能事件的基类"""
@abstractmethod
def __init__(self, char_instance: "Yixuan", comment: str = None):
self.char = char_instance
self.comment = comment
self.active: bool = False
self.max_duration: int = 0
self.last_active_tick: int = 0
self.regenerate_value_sum: float = 0
self.index = ""
self.active_times: int = 0
@abstractmethod
def update_status(self, skill_node: "SkillNode"):
"""更新自身状态，但不包含生效逻辑——char接收Preload的skill_node时调用"""
pass
def check_myself(self):
"""
在Buff阶段调用，检查自身是否处于激活状态，若自身激活，则调用effect_apply
"""
simulator: "Simulator" = self.char.sim_instance
if self.active:
self.apply_effect()
if simulator.tick >= self.last_active_tick + self.max_duration:
self.active = False
if YIXUAN_REPORT:
print(
f"第{self.active_times}次【{self.index}】结束了！总计为仪玄恢复了{self.regenerate_value_sum: .2f}点闪能！"
)
self.char.sim_instance.schedule_data.change_process_state()
self.regenerate_value_sum = 0
@abstractmethod
def apply_effect(self):
"""事件生效一次的方法"""
pass
class AuricArray(BaseAdrenalineEvent):
"""来自仪玄玄墨极阵释放过程中的回能效果的管理器对象"""
def __init__(self, char_instance: "Yixuan", comment: str = None):
super().__init__(char_instance, comment)
self.index = "玄墨极阵回能效果"
self.comment = (
"来自玄墨极阵的回能Buff，【普通攻击：玄墨极阵】期间会持续回复闪能，每秒7点，持续3秒"
)
self.active = False
self.max_duration: int = 180
self.last_active_tick: int = 0
self.regenerate_value = 7 / 60
self.active_times: int = 0
self.regenerate_value_sum = 0
def update_status(self, skill_node: "SkillNode"):
"""当检测到玄墨极阵的skill_node时，更新自身状态，"""
simulator: "Simulator" = self.char.sim_instance
if skill_node:
if skill_node.char_name != self.char.NAME:
return
if skill_node.skill_tag == "1371_SNA_B_1":
if self.active:
raise ValueError(
f"仪玄在展开玄墨极阵时，检测到上一个开始于{self.last_active_tick}tick的玄墨极阵的回能Buff尚未结束，仪玄不可能在短时间内打出两次玄墨极阵，请检查逻辑！"
)
self.active = True
self.active_times += 1
self.last_active_tick = simulator.tick
"""激活的当前tick也需要恢复闪能，但是并不是在本方法内部执行的，而是通过Buff触发器统一在Load阶段执行。"""
if YIXUAN_REPORT:
print(f"检测到技能{skill_node.skill_tag}（玄墨极阵）！【{self.index}】激活")
self.char.sim_instance.schedule_data.change_process_state()
def apply_effect(self):
"""事件生效，恢复一次闪能值"""
self.char.update_adrenaline(self.regenerate_value)
self.regenerate_value_sum += self.regenerate_value
class AuricInkUndercurrent(BaseAdrenalineEvent):
"""仪玄组队被动中，队友释放大招时的回能事件的管理器对象"""
def __init__(self, char_instance: "Yixuan", comment: str = None):
super().__init__(char_instance, comment)
self.index = "组队被动回能效果"
self.comment = "来自组队被动的回能Buff，队友释放大招后，仪玄会持续每秒恢复2点闪能，持续10秒"
self.active = False
self.max_duration: int = 600
self.last_active_tick: int = 0
self.regenerate_value_per_tick = 2 / 60
self.active_times: int = 0
self.regenerate_value_sum = 0
def update_status(self, skill_node: "SkillNode"):
"""当检测到队友大招时，更新自身状态，"""
simulator: "Simulator" = self.char.sim_instance
if skill_node:
# 过滤自己的技能
if skill_node.char_name == self.char.NAME:
return
if skill_node.skill.trigger_buff_level == 6:
self.active = True
self.active_times += 1
self.last_active_tick = simulator.tick
if YIXUAN_REPORT:
print(f"检测到队友释放大招：{skill_node.skill_tag}！【{self.index}】激活")
self.char.sim_instance.schedule_data.change_process_state()
def apply_effect(self):
"""事件生效，恢复一次闪能值"""
self.char.update_adrenaline(self.regenerate_value_per_tick)
self.regenerate_value_sum += self.regenerate_value_per_tick
================================================
FILE: zsim/sim_progress/Character/Yixuan/AdrenalineManagerClass.py
================================================
from typing import TYPE_CHECKING
from .AdrenalineEventClass import AuricArray, AuricInkUndercurrent, BaseAdrenalineEvent
if TYPE_CHECKING:
from zsim.sim_progress.Character.Yixuan import Yixuan
from zsim.sim_progress.Preload import SkillNode
ADRENALINE_EVENT_LIST = [AuricArray, AuricInkUndercurrent]
def adrenaline_event_factory(char_instance: "Yixuan") -> list:
event_list = []
for event in ADRENALINE_EVENT_LIST:
if event == AuricInkUndercurrent:
if not char_instance.additional_abililty_active:
continue
event_list.append(event(char_instance=char_instance))
return event_list
class AdrenalineManager:
"""仪玄有各种回复闪能的事件，所以统一写一个Manger来管理它们。"""
def __init__(self, char_instance: "Yixuan"):
self.char = char_instance
self.adrenaline_recover_event_group: list[BaseAdrenalineEvent] | None = None
def broadcast(self, skill_node: "SkillNode"):
"""向所有回能事件进行广播"""
if self.adrenaline_recover_event_group is None:
self.adrenaline_recover_event_group = adrenaline_event_factory(char_instance=self.char)
for event in self.adrenaline_recover_event_group:
event.update_status(skill_node=skill_node)
def refresh(self):
for event in self.adrenaline_recover_event_group:
event.check_myself()
================================================
FILE: zsim/sim_progress/Character/Yixuan/__init__.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YIXUAN_REPORT
from zsim.sim_progress.Character import Character
from zsim.simulator.simulator_class import Simulator
from ..utils.filters import (
_skill_node_filter,
_sp_update_data_filter,
)
from .AdrenalineManagerClass import AdrenalineManager
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
class Yixuan(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.sheer_attack_conversion_rate = {
0: 0.3,
1: 0.1,
2: 0,
3: 0,
} # 贯穿力转化字典{属性值（攻击力0，生命值1，防御力2，精通3）: 倍率}
self.adrenaline_limit = 120 # 闪能最大值
self.max_technique_points = 120 # 最大术法值
self.adrenaline = self.adrenaline_limit # 入场时，获得满闪能
self.technique_points: float = 0.0 if self.cinema < 1 else 120.0 # 术法值
self.adrenaline_manager = AdrenalineManager(char_instance=self)
self.listener_build = False
self.__adrenaline_recover_overtime_update_tick = 0 # 上次更新闪能自然恢复的时间
self.__technique_points_trans_ratio = 0.667 # 闪能转化成术法值的比例
self.auricink_point: int = 0 # 玄墨值
self.condensed_ink: int = 0 # 聚墨（2画效果）
self.regulated_breathing: bool = False # 调息（6画效果）
self.regulated_breathing_last_update_tick: int = 0
self.cinema_6_cd = 1800 # 6画获得调息的CD
# TODO: 队友极限支援监听
# TODO: 极限闪避监听
def special_resources(self, *args, **kwargs) -> None:
# 输入类型检查
if not self.listener_build:
if not isinstance(self.sim_instance, Simulator):
raise TypeError("仪玄对象中的sim_instance不是Simulator类")
self.sim_instance.listener_manager.listener_factory(
listener_owner=self,
initiate_signal="Yixuan_1",
sim_instance=self.sim_instance,
)
self.listener_build = True
skill_nodes: list["SkillNode"] = _skill_node_filter(*args, **kwargs)
tick = self.sim_instance.tick
for __nodes in skill_nodes:
"""向闪能回复事件管理器广播当前skill_node"""
self.adrenaline_manager.broadcast(skill_node=__nodes)
if __nodes.char_name != self.NAME:
continue
if __nodes.skill_tag == "1371_Q_A":
if self.auricink_point != 0:
print(
f"Warning：仪玄在玄墨值大于0的情况下再次释放了【{__nodes.skill.skill_text}】，这造成了玄墨值的溢出，请检查APL代码！"
)
if self.regulated_breathing:
if self.cinema < 6:
raise ValueError("仪玄在非6画状态下开启了调息状态，请检查代码！")
self.regulated_breathing = False
self.regulated_breathing_last_update_tick = tick
if YIXUAN_REPORT:
print(f"6画：仪玄释放【{__nodes.skill.skill_text}】，消耗一层调息！")
self.sim_instance.schedule_data.change_process_state()
else:
if self.technique_points < 120:
raise ValueError("仪玄的术法值不足！请检查APL！")
self.technique_points = 0
self.auricink_point = min(1, self.auricink_point + 1)
elif __nodes.skill_tag == "1371_Q":
if self.cinema >= 2:
self.condensed_ink = min(1, self.condensed_ink + 1)
if YIXUAN_REPORT:
print(
f"2画：检测到仪玄释放喧响大招【{__nodes.skill.skill_text}】，获得1点聚墨值！"
)
self.sim_instance.schedule_data.change_process_state()
if self.cinema == 6:
if (
tick - self.regulated_breathing_last_update_tick >= self.cinema_6_cd
) or self.regulated_breathing_last_update_tick == 0:
self.regulated_breathing = True
if YIXUAN_REPORT:
print(
f"6画：检测到技能【{__nodes.skill.skill_text}】，仪玄获得一层调息"
)
self.sim_instance.schedule_data.change_process_state()
else:
print(
f"6画：检测到技能【{__nodes.skill.skill_text}】，但是仪玄调息的内置CD尚未转好，所以无法获得调息"
)
elif __nodes.skill_tag == "1371_SNA_B_1":
if self.auricink_point <= 0:
raise ValueError("仪玄的玄墨值不足！请检查APL！")
self.auricink_point -= 1
elif __nodes.skill_tag == "1371_Cinema_2":
if self.cinema < 2:
raise ValueError(
f"仪玄当前影画为{self.cinema}，未解锁2画，APL却抛出了2画专属的SkillNode，请检查APL"
)
if self.condensed_ink < 1:
raise ValueError("仪玄当前的聚墨点数不足！请检查APL")
self.condensed_ink -= 1
if YIXUAN_REPORT:
print(f"2画：仪玄追加释放【{__nodes.skill.skill_text}】，消耗1点聚墨值")
self.sim_instance.schedule_data.change_process_state()
# 更新术法值和闪能值
self.__update_adrenaline(skill_node=__nodes)
def update_sp(self, sp_value: float):
"""仪玄没有能量值，所以这里update_sp直接return置空"""
return
def update_adrenaline(self, sp_value: int | float):
"""可全局强制更新能量的方法——仪玄特化版"""
if sp_value < 0:
# 当检测到闪能消耗时候，进行术法值的转化
technique_points_delta = abs(sp_value) * self.__technique_points_trans_ratio
self.technique_points = min(
self.technique_points + technique_points_delta,
self.max_technique_points,
)
if YIXUAN_REPORT:
print(
f"仪玄消耗了{abs(sp_value):.2f}点闪能值，转化为{technique_points_delta:.2f}点术法值！当前术法值为：{self.technique_points:.2f}"
)
self.sim_instance.schedule_data.change_process_state()
self.adrenaline += sp_value
self.adrenaline = max(0.0, min(self.adrenaline, self.adrenaline_limit))
# if abs(sp_value) >= 0.1:
# print(f"仪玄的闪能改变了{sp_value:.2f}点，当前为：{self.adrenaline:.2f}")
def __update_adrenaline(self, skill_node: "SkillNode"):
"""char对象内部更新闪能的方法"""
if skill_node.char_name != self.NAME:
raise ValueError(f"{self.NAME}的更新闪能的方法接收到了非仪玄的SkillNode")
adrenaline_delta = (
skill_node.skill.adrenaline_recovery - skill_node.skill.adrenaline_consume
)
if adrenaline_delta <= 0 and abs(adrenaline_delta) > self.adrenaline:
raise ValueError(
f"检测到技能{skill_node.skill_tag}【{skill_node.skill.skill_text}】企图消耗{skill_node.skill.adrenaline_consume}点闪能，但是仪玄当前的闪能不足：{self.adrenaline}，请检查APL"
)
self.update_adrenaline(adrenaline_delta)
def update_sp_overtime(self, args, kwargs):
"""
该函数会在Preload以及Schedule阶段被调用两次，当在Preload阶段调用时，sp_regen_data为空，
只有在Schedule阶段被调用时，函数才会被执行。
所以sp_regen_data虽然和闪能回复无关，但确是保证函数只被运行一次的关键。
"""
sp_regen_data = _sp_update_data_filter(*args, **kwargs)
if sp_regen_data:
if (
self.sim_instance.tick == self.__adrenaline_recover_overtime_update_tick
and self.__adrenaline_recover_overtime_update_tick != 0
):
raise ValueError(
"检测到仪玄闪能的自然恢复逻辑在同一个tick被调用了两次！请检查函数！"
)
sp_change_per_tick = 2 / 60
self.update_adrenaline(sp_change_per_tick)
self.__adrenaline_recover_overtime_update_tick = self.sim_instance.tick
def refresh_myself(self):
"""回能更新的几个管理器需要每个tick更新一次，所以用这个接口进行更新。"""
self.adrenaline_manager.refresh()
def get_resources(self) -> tuple[str, float]:
return "闪能", self.adrenaline
def get_special_stats(self, *args, **kwargs) -> dict[str, int | float | bool]:
"""获取简仪玄特殊状态"""
return {
"术法值": self.technique_points,
"玄墨值": self.auricink_point,
"聚墨点数": self.condensed_ink,
"调息层数": self.regulated_breathing,
}
================================================
FILE: zsim/sim_progress/Character/Yuzuha/__init__.py
================================================
from typing import TYPE_CHECKING
from zsim.define import YUZUHA_REPORT
from zsim.models.event_enums import PostInitObjectType as PIOT
from zsim.models.event_enums import SpecialStateUpdateSignal as SSUS
from zsim.sim_progress.Preload import SkillNode
from ...data_struct.SchedulePreload import schedule_preload_event_factory
from ..character import Character
from ..utils.filters import _skill_node_filter
if TYPE_CHECKING:
from zsim.sim_progress.data_struct.enemy_special_state_manager.special_classes import SweetScare
from zsim.simulator.simulator_class import Simulator
class Yuzuha(Character):
def __init__(self, **kwargs):
"""柚叶的特殊资源"""
super().__init__(**kwargs)
self.sweet_scare: SweetScare | None = None
self.sugar_points: int = 3 # 甜度点
self.max_sugar_points: int = 6
self.hard_candy_shot_tag = "1411_CoAttack_A"
def special_resources(self, *args, **kwargs) -> None:
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
sim_instance: "Simulator" = self.sim_instance
sim_instance.schedule_data.enemy.special_state_manager.broadcast_and_update(
signal=SSUS.CHARACTER, skill_node=node
)
if node.skill_tag == "1411_Assault_Aid_B" and self.cinema < 6:
raise ValueError(
"企图在非6画状态下对支援突击进行蓄力！请检查define中的招架支援配置！"
)
if node.char_name != self.NAME:
continue
if node.skill.labels is not None and "sugar_points" in node.skill.labels:
sugar_points = node.skill.labels["sugar_points"]
self.update_sugar_points(value=sugar_points)
if YUZUHA_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"{self.NAME}释放了技能{node.skill_tag}，{'获得' if sugar_points > 0 else '消耗'}了{abs(sugar_points)}甜度点！当前甜度点为{self.sugar_points}"
)
if node.skill.trigger_buff_level == 6:
from zsim.sim_progress.data_struct.sp_update_data import ScheduleRefreshData
report_namelist = []
for char_obj in sim_instance.char_data.char_obj_list:
if char_obj.NAME == self.NAME:
continue
report_namelist.append(char_obj.NAME)
schedule_refresh_event = ScheduleRefreshData(
sp_target=(char_obj.NAME,),
sp_value=25,
)
event_list = sim_instance.schedule_data.event_list
event_list.append(schedule_refresh_event)
else:
if YUZUHA_REPORT:
sim_instance.schedule_data.change_process_state()
print(
f"【柚叶回能】：柚叶发动大招，为{[_name for _name in report_namelist]}恢复25点能量值"
)
def update_sugar_points(self, value: int):
"""更新甜度点"""
if value < 0 and abs(self.sugar_points) < abs(value):
if YUZUHA_REPORT:
sim_instance: "Simulator" = self.sim_instance
sim_instance.schedule_data.change_process_state()
print(
f"【甜度点警告】：甜度点不足！当前甜度点为{self.sugar_points}， 甜度点消耗值为：{abs(value)}"
)
self.sugar_points = 0
return
self.sugar_points += value
if self.sugar_points > self.max_sugar_points:
self.sugar_points = self.max_sugar_points
def spawn_hard_candy_shot(self, update_signal: "SkillNode" = None):
"""生成一次硬糖射击"""
# self.update_sugar_points(value=-1)
skill_tag_list = [self.hard_candy_shot_tag]
preload_tick_list = [self.sim_instance.tick]
schedule_preload_event_factory(
skill_tag_list=skill_tag_list,
preload_tick_list=preload_tick_list,
preload_data=self.sim_instance.preload.preload_data,
apl_priority_list=[-1],
sim_instance=self.sim_instance,
)
if YUZUHA_REPORT:
self.sim_instance.schedule_data.change_process_state()
print(
f"【硬糖射击】{update_signal.skill_tag if update_signal is not None else None}触发了一次硬糖射击！"
)
def POST_INIT_DATA(self, sim_instance: "Simulator"):
"""柚叶的后置初始化函数，用于后置创建甜蜜惊吓特殊状态"""
enemy = sim_instance.schedule_data.enemy
self.sweet_scare = enemy.special_state_manager.special_state_factory(
state_type=PIOT.SweetScare
)
self.sp = 40.00 if self.cinema < 1 else 70.00 # 初始化能量值
if self.cinema >= 2:
sim_instance.listener_manager.listener_factory(
listener_owner=self, initiate_signal="Yuzuha_1", sim_instance=sim_instance
)
if self.cinema >= 6:
sim_instance.listener_manager.listener_factory(
listener_owner=self, initiate_signal="Yuzuha_2", sim_instance=sim_instance
)
def get_resources(self, *args, **kwargs) -> tuple[str | None, int | float | None]:
return "甜度点", self.sugar_points
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
pass
================================================
FILE: zsim/sim_progress/Character/Zhuyuan.py
================================================
from ..Preload import SkillNode
from ..Report import report_to_log
from .character import Character
from .utils.filters import _skill_node_filter
class Zhuyuan(Character):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.shotshells = 0 # 霰弹个数
if self.cinema >= 1: # 影画1的额外子弹逻辑
self.allow_restore = True
self.QTE_STORED = 6
self.Q_STORED = 9
self.shotshells_warehouse: list = []
else:
self.allow_restore = False
def special_resources(self, *args, **kwargs):
# 输入类型检查
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
# 攒子弹逻辑
if node.skill_tag in [
"1241_E_EX",
"1241_E_EX_A",
"1241_QTE",
"1241_Q",
"1241_Assault_Aid",
]:
self.shotshells = min(self.shotshells + 3, 9)
if self.allow_restore and node.skill_tag in ["1241_QTE", "1241_Q"]:
self.shotshells_warehouse.append(node.skill_tag)
# 消耗子弹逻辑
if "1241_S" in node.skill_tag:
if self.shotshells <= 0:
report_to_log("[Zhuyuan]: 弹夹为空, 无法使用")
print("[Zhuyuan]:弹夹为空, 无法使用")
self.shotshells = max(self.shotshells - 1, 0)
if self.shotshells == 0 and self.allow_restore:
if self.shotshells_warehouse:
popping_shotshells = self.shotshells_warehouse.pop()
for shell in self.shotshells_warehouse[:]:
if shell == popping_shotshells:
self.shotshells_warehouse.remove(shell)
if popping_shotshells == "1241_QTE":
self.shotshells += self.QTE_STORED
elif popping_shotshells == "1241_Q":
self.shotshells += self.Q_STORED
def get_resources(self, *args, **kwargs) -> tuple[str | None, int | float | bool | None]:
return "强化霰弹", self.shotshells
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
if self.allow_restore:
stored_shotshells = (6 if "1241_QTE" in self.shotshells_warehouse else 0) + (
9 if "1241_Q" in self.shotshells_warehouse else 0
)
else:
stored_shotshells = 0
return {
"强化霰弹": self.shotshells,
"缓存霰弹": stored_shotshells,
"强化霰弹(含缓存)": self.shotshells + stored_shotshells,
}
================================================
FILE: zsim/sim_progress/Character/__init__.py
================================================
import importlib
from typing import TYPE_CHECKING
from .character import Character
from .skill_class import lookup_name_or_cid
if TYPE_CHECKING:
from zsim.models.session.session_run import CharConfig, ExecAttrCurveCfg, ExecWeaponCfg
__char_module_map = {
"苍角": "Soukaku",
"莱特": "Lighter",
"艾莲": "Ellen",
"雅": "Miyabi",
"11号": "Soldier11",
"青衣": "Qingyi",
"朱鸢": "Zhuyuan",
"伊芙琳": "Evelyn",
"零号·安比": "Soldier0_Anby",
"扳机": "Trigger",
"柳": "Yanagi",
"简": "Jane",
"薇薇安": "Vivian",
"耀嘉音": "AstraYao",
"雨果": "Hugo",
"仪玄": "Yixuan",
"柚叶": "Yuzuha",
"爱丽丝": "Alice",
"席德": "Seed",
}
def character_factory(
char_config: "CharConfig",
*,
sim_cfg: "ExecAttrCurveCfg | ExecWeaponCfg | None" = None,
) -> Character:
"""
角色工厂函数，用于创建角色实例
参数：
- char_config: CharConfig对象，包含角色的所有配置信息
- sim_cfg: 模拟配置对象，可选参数，用于特殊模拟模式
返回：
- Character: 角色实例
"""
name, CID = lookup_name_or_cid(char_config.name, char_config.CID)
if name in __char_module_map:
try:
module_name = __char_module_map[name]
module = importlib.import_module(f".{module_name}", package=__name__)
character_class: type[Character] = getattr(module, module_name)
return character_class(char_config=char_config, sim_cfg=sim_cfg)
except ModuleNotFoundError:
return Character(char_config=char_config, sim_cfg=sim_cfg)
else:
return Character(char_config=char_config, sim_cfg=sim_cfg)
================================================
FILE: zsim/sim_progress/Character/character.py
================================================
from __future__ import annotations
import logging
from typing import TYPE_CHECKING
import polars as pl
from zsim.define import (
CHARACTER_DATA_PATH,
EQUIP_2PC_DATA_PATH,
SUB_STATS_MAPPING,
WEAPON_DATA_PATH,
)
from zsim.models.session.session_run import CharConfig, ExecAttrCurveCfg, ExecWeaponCfg
from zsim.sim_progress.Report import report_to_log
from .skill_class import Skill, lookup_name_or_cid
from .utils.filters import _skill_node_filter, _sp_update_data_filter
if TYPE_CHECKING:
from zsim.sim_progress.Buff.buff_class import Buff
from zsim.sim_progress.data_struct.sp_update_data import SPUpdateData
from zsim.sim_progress.Preload.SkillsQueue import SkillNode
from zsim.simulator.simulator_class import Simulator
class Character:
def __init__(
self,
*,
char_config: CharConfig,
sim_cfg: ExecAttrCurveCfg | ExecWeaponCfg | None = None,
):
"""
调用时，会生成包含全部角色基础信息的对象，自动从数据库中查找全部信息
参数：
- char_config: CharConfig对象，包含角色的所有配置信息
- sim_cfg: 模拟配置对象，可选参数，用于特殊模拟模式
自生成参数：
-self.level = 60 默认角色等级，传给防御区用
-记录每个基础属性来源的各参数，主要来自查表
-包含角色全部技能信息的 Skill 对象，以及来自 Skill 的 action_list, skills_dict
暴击非配平逻辑（直接读取）：
scCRIT: 暴击率副词条
scCRIT_DMG: 暴击伤害副词条
是否配平由传入参数 char_config.crit_balancing 控制
配平逻辑下，暴伤与暴击率词条将会被重新分配，且没有基于整数词条数量的自动重整
"""
# 从CharConfig对象中提取参数
name = char_config.name
CID = char_config.CID
weapon = char_config.weapon
weapon_level = char_config.weapon_level
equip_style = char_config.equip_style
equip_set4 = char_config.equip_set4
equip_set2_a = char_config.equip_set2_a
equip_set2_b = char_config.equip_set2_b
equip_set2_c = char_config.equip_set2_c
drive4 = char_config.drive4
drive5 = char_config.drive5
drive6 = char_config.drive6
scATK_percent = char_config.scATK_percent
scATK = char_config.scATK
scHP_percent = char_config.scHP_percent
scHP = char_config.scHP
scDEF_percent = char_config.scDEF_percent
scDEF = char_config.scDEF
scAnomalyProficiency = char_config.scAnomalyProficiency
scPEN = char_config.scPEN
scCRIT = char_config.scCRIT
scCRIT_DMG = char_config.scCRIT_DMG
sp_limit = char_config.sp_limit
cinema = char_config.cinema
crit_balancing = char_config.crit_balancing
crit_rate_limit = char_config.crit_rate_limit
# 从数据库中查找角色信息，并核对必填项
self.NAME, self.CID = lookup_name_or_cid(name, CID)
# 初始化为0的各属性
self.baseATK = 0.0
self.ATK_percent = 0.0
self.ATK_numeric = 0.0
self.overall_ATK_percent = 0.0
self.overall_ATK_numeric = 0.0
self.baseHP = 0.0
self.HP_percent = 0.0
self.HP_numeric = 0.0
self.overall_HP_percent = 0.0
self.overall_HP_numeric = 0.0
self.baseDEF = 0.0
self.DEF_percent = 0.0
self.DEF_numeric = 0.0
self.overall_DEF_percent = 0.0
self.overall_DEF_numeric = 0.0
self.baseIMP = 0.0
self.IMP_percent = 0.0
self.IMP_numeric = 0.0
self.overall_IMP_percent = 0.0
self.overall_IMP_numeric = 0.0
self.baseAP = 0.0
self.AP_percent = 0.0
self.AP_numeric = 0.0
self.overall_AP_percent = 0.0
self.overall_AP_numeric = 0.0
self.baseAM = 0.0
self.AM_percent = 0.0
self.AM_numeric = 0.0
self.overall_AM_percent = 0.0
self.overall_AM_numeric = 0.0
self.CRIT_rate_numeric = 0.0 # 暴击率（非配平逻辑使用）
self.CRIT_damage_numeric = 0.0 # 暴击伤害（非配平逻辑使用）
self.base_sp_regen = 0.0
self.sp_regen_percent = 0.0
self.sp_regen_numeric = 0.0
self.ICE_DMG_bonus = 0.0
self.FIRE_DMG_bonus = 0.0
self.PHY_DMG_bonus = 0.0
self.ETHER_DMG_bonus = 0.0
self.ELECTRIC_DMG_bonus = 0.0
self.ALL_DMG_bonus = 0.0
self.Trigger_DMG_bonus = 0.0
self.PEN_ratio = 0.0
self.PEN_numeric = 0.0
# 单独初始化的各组件
self.level: int = 60
self.weapon_ID: str | None = weapon
self.weapon_level: int = weapon_level
self.cinema: int = cinema
self.baseCRIT_score: float = 60
self.sp_get_ratio: float = 1 # 能量获得效率
self.sp_limit: int = int(sp_limit)
self.sp: float = 40.0
self.decibel: float = 1000.0
self.specialty: str | None
self.element_type: int
self.crit_balancing: bool = crit_balancing
self.crit_rate_limit: float = crit_rate_limit
self.sheer_attack_conversion_rate: dict[int, float] | None = None
# 初始化角色基础属性 .\data\character.csv
self._init_base_attribute(name)
# fmt: off
# 如果并行配置没有移除套装，就初始化套装效果和主副词条
if sim_cfg is not None:
if isinstance(sim_cfg, ExecAttrCurveCfg):
if not sim_cfg.remove_equip:
self.__init_all_equip_static(drive4, drive5, drive6,
equip_set2_a, equip_set2_b, equip_set2_c, equip_set4, equip_style,
scATK, scATK_percent, scAnomalyProficiency, scCRIT,
scCRIT_DMG, scDEF, scDEF_percent, scHP, scHP_percent, scPEN)
self.__init_attr_curve_config(sim_cfg)
self._init_weapon_primitive(weapon, weapon_level)
elif isinstance(sim_cfg, ExecWeaponCfg):
self.__init_all_equip_static(drive4, drive5, drive6,
equip_set2_a, equip_set2_b, equip_set2_c, equip_set4, equip_style,
scATK, scATK_percent, scAnomalyProficiency, scCRIT,
scCRIT_DMG, scDEF, scDEF_percent, scHP, scHP_percent, scPEN)
self._init_weapon_primitive(sim_cfg.weapon_name, sim_cfg.weapon_level) # 覆盖武器基础属性
else:
self.__init_all_equip_static(drive4, drive5, drive6,
equip_set2_a, equip_set2_b, equip_set2_c, equip_set4, equip_style,
scATK, scATK_percent, scAnomalyProficiency, scCRIT,
scCRIT_DMG, scDEF, scDEF_percent, scHP, scHP_percent, scPEN)
# 初始化武器基础属性 .\data\weapon.csv
self._init_weapon_primitive(weapon, weapon_level)
self.additional_abililty_active: bool | None = None # 角色是否激活组队被动，该参数将在Buff模块初始化完成后进行赋值
skill_level_addon = 4 if self.cinema >=5 else (2 if self.cinema >= 3 else 0)
skills_level: dict[str, int] = {
"normal_level": 12 + skill_level_addon,
"special_level": 12 + skill_level_addon,
"dodge_level": 12 + skill_level_addon,
"chain_level": 12 + skill_level_addon,
"assist_level": 12 + skill_level_addon,
}
self.statement = Character.Statement(self, crit_balancing=crit_balancing)
self.skill_object: Skill = Skill(name=self.NAME, CID=self.CID, **skills_level, char_obj=self)
self.action_list = self.skill_object.action_list
self.skills_dict = self.skill_object.skills_dict
self.dynamic = self.Dynamic(self)
self.sim_instance: "Simulator | None" = None # 模拟器实例
self.equip_buff_map: dict[int, "Buff"] = {} # 来自装备的Buff0的指针
# fmt: off
def __init_all_equip_static(self, drive4, drive5, drive6,
equip_set2_a, equip_set2_b, equip_set2_c, equip_set4, equip_style,
scATK, scATK_percent, scAnomalyProficiency, scCRIT,
scCRIT_DMG, scDEF, scDEF_percent, scHP, scHP_percent, scPEN):
# fmt: on
# 初始化套装效果 .\data\equip_set_2pc.csv
self._init_equip_set(
equip_style, equip_set4, equip_set2_a, equip_set2_b, equip_set2_c
)
# 初始化主词条
self._init_main_stats(drive4, drive5, drive6)
# 初始化副词条
self._init_sub_stats(
scATK_percent, scATK, scHP_percent,scHP, scDEF_percent, scDEF, scAnomalyProficiency, scPEN, scCRIT, scCRIT_DMG,
)
# fmt: on
class Statement:
def __init__(self, char: "Character", crit_balancing: bool):
"""
-char_class : 已实例化的角色
用于计算角色面板属性：
-传入已经实例化的 Character 对象，计算出目前的角色面板
-如果和 Character 对象同时调用，那么本对象会储存角色的局外面板属性
-可在调用本类前对一个 Character 对象内的值进行更改，以实现手动调整面板的功能
调用格式为：
char_dynamic = Character.Statement(char) # 需要传入一个角色对象
获取面板数值：
-使用属性名调用，格式为 char_dynamic.ATK
-使用内置字典调用，格式为 char_dynamic.statement['ATK'] # 谁会想用这个方法呢，这个字典不过是方便输出 log 罢了
值得注意的是，这个类有许多属性直接继承自 Character，但是防止混淆没有写成子类，但你依然可以直接调用 NAME、CID 等静态参数
包含的方法：
-还是没有！这个类是被动的，不应该自己变化，需要的时候重新生成，你要强行写函数改也行（乐
"""
self.NAME = char.NAME
self.CID = char.CID
self.ATK = (char.baseATK * (1 + char.ATK_percent) + char.ATK_numeric) * (
1 + char.overall_ATK_percent
) + char.overall_ATK_numeric
self.HP = (char.baseHP * (1 + char.HP_percent) + char.HP_numeric) * (
1 + char.overall_HP_percent
) + char.overall_HP_numeric
self.DEF = (char.baseDEF * (1 + char.DEF_percent) + char.DEF_numeric) * (
1 + char.overall_DEF_percent
) + char.overall_DEF_numeric
self.IMP = (char.baseIMP * (1 + char.IMP_percent) + char.IMP_numeric) * (
1 + char.overall_IMP_percent
) + char.overall_IMP_numeric
self.AP = (char.baseAP * (1 + char.AP_percent) + char.AP_numeric) * (
1 + char.overall_AP_percent
) + char.overall_AP_numeric
self.AM = (char.baseAM * (1 + char.AM_percent) + char.AM_numeric) * (
1 + char.overall_AM_percent
) + char.overall_AM_numeric
# 更换balancing参数可实现不同的逻辑，默认为True，即配平逻辑
self.CRIT_damage, self.CRIT_rate = self._func_statement_CRIT(
char.baseCRIT_score,
char.CRIT_rate_numeric,
char.CRIT_damage_numeric,
char.crit_rate_limit,
balancing=crit_balancing,
)
self.sp_regen = char.base_sp_regen * (1 + char.sp_regen_percent) + char.sp_regen_numeric
self.sp_get_ratio = char.sp_get_ratio
self.sp_limit = char.sp_limit
# 储存目前能量与喧响的参数
self.PEN_ratio = char.PEN_ratio
self.PEN_numeric = char.PEN_numeric
self.ICE_DMG_bonus = char.ICE_DMG_bonus
self.FIRE_DMG_bonus = char.FIRE_DMG_bonus
self.PHY_DMG_bonus = char.PHY_DMG_bonus
self.ETHER_DMG_bonus = char.ETHER_DMG_bonus
self.ELECTRIC_DMG_bonus = char.ELECTRIC_DMG_bonus
# 将当前对象 (self) 的所有非可调用（即不是方法或函数）的属性收集到一个字典中
self.statement = {
attr: getattr(self, attr)
for attr in dir(self)
if not callable(getattr(self, attr)) and not attr.startswith("__")
}
report_to_log(f"[CHAR STATUS]:{self.NAME}:{str(self.statement)}")
@staticmethod
def _func_statement_CRIT(
CRIT_score: float,
CRIT_rate_numeric: float,
CRIT_damage_numeric: float,
CRIT_rate_limit: float,
balancing: bool,
) -> tuple[float, float]:
"""
双暴状态函数
balancing : 是否使用配平逻辑
CRIT_score : 暴击评分
CRIT_rate_numeric : 暴击率数值
CRIT_damage_numeric : 暴击伤害数值
返回：
CRIT_damage : 暴击伤害
CRIT_rate : 暴击率
默认为True，即配平逻辑，会使用暴击评分、暴击暴伤输出，集中计算暴击率与暴击伤害
若为False，则忽略传入的暴击评分，直接返回给定的数值
"""
# 参数有效性验证
if not (0 <= CRIT_score):
raise ValueError("CRIT_score must be above 0")
if not (0 <= CRIT_rate_numeric):
raise ValueError("CRIT_rate_numeric must be above 0")
if not (0 <= CRIT_damage_numeric):
raise ValueError("CRIT_damage_numeric must be above 0")
if not (0 <= CRIT_rate_limit <= 1):
raise ValueError("CRIT_rate_limit must be between 0 and 1")
if balancing:
limit_score: float = CRIT_rate_limit * 400
if CRIT_score >= limit_score:
CRIT_rate = CRIT_rate_limit
CRIT_damage = (CRIT_score - CRIT_rate * 200) / 100
else:
CRIT_damage = max(0.5, CRIT_score / 200)
CRIT_rate = (CRIT_score / 100 - CRIT_damage) / 2
else:
CRIT_damage = CRIT_damage_numeric
CRIT_rate = CRIT_rate_numeric
return min(5.0, CRIT_damage), min(1.0, CRIT_rate)
def __str__(self) -> str:
return f"角色静态面板：{self.NAME}"
class Dynamic:
"""用于记录角色各种动态信息的类，主要和APL模块进行互动。"""
def __init__(self, char_instantce: Character):
self.character = char_instantce
self.lasting_node = LastingNode(self.character)
from zsim.sim_progress.data_struct.QuickAssistSystem.quick_assist_manager import (
QuickAssistManager,
)
self.quick_assist_manager = QuickAssistManager(self.character)
self._on_field = False # 角色是否在前台
self._switching_in_tick = 0 # 角色切到前台状态的时间点
self._switching_out_tick = 0 # 角色切到后台状态的时间点
def reset(self):
self.lasting_node.reset()
self.on_field = False
@property
def on_field(self) -> bool:
return self._on_field
@on_field.setter
def on_field(self, value: bool):
assert self.character.sim_instance is not None
tick = self.character.sim_instance.tick
if self.on_field and not value:
# 角色on_field状态的下降沿，即角色从前台切换到后台
self._switching_out_tick = tick
elif not self.on_field and value:
# 角色on_field状态的上升沿，即角色从后台切换到前台
self._switching_in_tick = tick
self._on_field = value
def is_off_field_within(self, max_ticks: int) -> bool:
"""判断角色切到后台的时间是否小于等于指定时间"""
assert self.character.sim_instance is not None
if self.on_field:
return False
current_tick = self.character.sim_instance.tick
return current_tick - self._switching_out_tick <= max_ticks
def is_on_field_within(self, max_ticks: int) -> bool:
"""判断角色切到前台的时间是否小于等于指定时间"""
assert self.character.sim_instance is not None
if not self.on_field:
return False
current_tick = self.character.sim_instance.tick
return current_tick - self._switching_in_tick <= max_ticks
def is_available(self, tick: int):
"""查询角色当前tick是否有空"""
lasting_node = self.dynamic.lasting_node
if lasting_node is None:
return ValueError("角色没有LastingNode")
node = lasting_node.node
if node is None:
return True
if node.end_tick >= tick:
return False
return True
def __mapping_csv_to_attr(self, row: dict):
self.baseATK += float(row.get("base_ATK", 0))
self.ATK_percent += float(row.get("ATK%", 0))
self.DEF_percent += float(row.get("DEF%", 0))
self.HP_percent += float(row.get("HP%", 0))
self.IMP_percent += float(row.get("IMP%", 0))
self.overall_ATK_percent += float(row.get("oATK%", 0))
self.overall_DEF_percent += float(row.get("oDEF%", 0))
self.overall_HP_percent += float(row.get("oHP%", 0))
self.overall_IMP_percent += float(row.get("oIMP%", 0))
self.AM_percent += float(row.get("Anomaly_Mastery", 0))
self.AP_numeric += float(row.get("Anomaly_Proficiency", 0))
self.sp_regen_percent += float(row.get("Regen%", 0))
self.sp_regen_numeric += float(row.get("Regen", 0))
self.sp_get_ratio += float(row.get("Get_ratio", 0))
self.PEN_ratio += float(row.get("pen%", 0))
self.ICE_DMG_bonus += float(row.get("ICE_DMG_bonus", 0))
self.FIRE_DMG_bonus += float(row.get("FIRE_DMG_bonus", 0))
self.ELECTRIC_DMG_bonus += float(row.get("ELECTRIC_DMG_bonus", 0))
self.PHY_DMG_bonus += float(row.get("PHY_DMG_bonus", 0))
self.ETHER_DMG_bonus += float(row.get("ETHER_DMG_bonus", 0))
if self.crit_balancing:
crit_score_delta = 100 * (
float(row.get("Crit_Rate", 0)) * 2 + float(row.get("Crit_DMG", 0))
)
self.baseCRIT_score += crit_score_delta
else:
self.CRIT_rate_numeric += float(row.get("Crit_Rate", 0))
self.CRIT_damage_numeric += float(row.get("Crit_DMG", 0))
def _init_base_attribute(self, char_name: str):
"""
初始化角色基础属性。
根据角色名称，从CSV文件中读取角色的基础属性数据，并将其赋值给角色对象。
参数:
char_name(str): 角色的名称。
"""
if not isinstance(char_name, str) or not char_name.strip():
raise ValueError("角色名称必须是非空字符串")
try:
row = (
pl.scan_csv(CHARACTER_DATA_PATH)
.filter(pl.col("name") == char_name)
.collect()
.to_dicts()
)
if row:
# 将对应记录提取出来，并赋值给角色对象
row_0: dict = row[0]
self.baseATK = float(row_0.get("基础攻击力", 0))
self.baseHP = float(row_0.get("基础生命值", 0))
self.baseDEF = float(row_0.get("基础防御力", 0))
self.baseIMP = float(row_0.get("基础冲击力", 0))
self.baseAP = float(row_0.get("基础异常精通", 0))
self.baseAM = float(row_0.get("基础异常掌控", 0))
# self.baseCRIT_score = float(row_0.get("基础暴击分数", 60))
self.CRIT_rate_numeric = float(
row_0.get("基础暴击率", 0)
) # 此处不需要根据暴击配平区分
self.CRIT_damage_numeric = float(row_0.get("基础暴击伤害", 1))
self.baseCRIT_score = 100 * (self.CRIT_rate_numeric * 2 + self.CRIT_damage_numeric)
# print(f'{self.NAME}的核心被动初始化完成！当前暴击分数为：{self.baseCRIT_score}')
self.PEN_ratio = float(row_0.get("基础穿透率", 0))
self.PEN_numeric = float(row_0.get("基础穿透值", 0))
self.base_sp_regen = float(row_0.get("基础能量自动回复", 0))
self.base_sp_get_ratio = float(row_0.get("基础能量获取效率", 1))
self.specialty = row_0.get("角色特性", None) # 角色特性，强攻、击破等
self.aid_type = row_0.get("支援类型", None)
self.element_type = row_0.get("角色属性", 0)
if self.element_type is None or self.element_type < 0:
raise NotImplementedError(f"角色{char_name}的属性类型未定义")
# CID特殊处理，避免不必要的类型转换
cid_value: int | None = row_0.get("CID", None)
self.CID = int(cid_value) if cid_value is not None else -1
else:
raise ValueError(f"角色{char_name}不存在")
except FileNotFoundError:
logging.error("找不到角色数据文件，请检查路径是否正确。")
raise
except Exception as e:
logging.error(f"初始化角色属性时发生未知错误：{e}")
raise
def _init_weapon_primitive(self, weapon: str | None, weapon_level: int) -> None:
"""初始化武器主属性（适配新版 weapon.csv）"""
if weapon is None:
return
df = pl.read_csv(WEAPON_DATA_PATH)
row = df.filter(pl.col("名称") == weapon)
if row.height > 0:
row_0 = row.row(0, named=True)
base_atk = float(row_0["60级基础攻击力"])
attr_value = row_0["60级高级属性值"]
self.baseATK += base_atk
# 处理高级属性
attr_type = row_0["高级属性"]
attr_value = float(attr_value)
if attr_type in ["攻击力"]:
self.ATK_percent += attr_value if attr_value < 1 else 0
elif attr_type in ["暴击率"]:
if self.crit_balancing:
self.baseCRIT_score += attr_value * 200 # 1%暴击率=2分 -> 1暴击率=200分
else:
self.CRIT_rate_numeric += attr_value
elif attr_type in ["暴击伤害"]:
if self.crit_balancing:
self.baseCRIT_score += attr_value * 100 # 1暴击伤害=100分
else:
self.CRIT_damage_numeric += attr_value
elif attr_type in ["异常精通"]:
self.AP_numeric += attr_value
elif attr_type in ["冲击力"]:
self.IMP_percent += attr_value
elif attr_type in ["防御力"]:
self.DEF_percent += attr_value
elif attr_type in ["生命值"]:
self.HP_percent += attr_value
elif attr_type in ["穿透率"]:
self.PEN_ratio += attr_value
elif attr_type in ["能量自动回复"]:
self.sp_regen_percent += attr_value
else:
raise ValueError(f"未知的武器高级属性类型：{attr_type}")
else:
raise ValueError(f"请输入正确的武器名称，{weapon} 不存在！")
def _init_equip_set(
self,
equip_style: str,
equip_set4: str | None,
equip_set2_a: str | None,
equip_set2_b: str | None,
equip_set2_c: str | None,
):
"""初始化套装效果, Character类仅计算二件套"""
if equip_style not in ["4+2", "2+2+2"]:
raise ValueError("请输入正确的套装格式")
# 将自身套装效果抄录
equip_set_all = [equip_set4, equip_set2_a, equip_set2_b, equip_set2_c]
# 检查四件套与三个二件套是否有相同的套装
used_sets = []
if equip_set4:
used_sets.append(equip_set4)
two_piece_sets = [equip_set2_a, equip_set2_b, equip_set2_c]
for set_name in two_piece_sets:
if set_name:
if set_name in used_sets:
raise ValueError("四件套与二件套中请勿输入重复的套装名称")
del used_sets, two_piece_sets
self.equip_set4, self.equip_set2_a, self.equip_set2_b, self.equip_set2_c = equip_set_all
# 4+2格式则移出2b、2c
if equip_style == "4+2": # 非空判断
if equip_set2_b in equip_set_all: # 别删这个if，否则输入None会报错
equip_set_all.remove(equip_set2_b)
if equip_set2_c in equip_set_all: # 别删这个if，否则输入None会报错
equip_set_all.remove(equip_set2_c)
else:
if equip_set4 in equip_set_all: # 别删这个if，否则输入None会报错
equip_set_all.remove(equip_set4)
if equip_set_all is not None: # 全空则跳过
lf = pl.scan_csv(EQUIP_2PC_DATA_PATH)
for equip_2pc in equip_set_all:
if bool(equip_2pc): # 若二件套非空，则继续
row: list[dict] = lf.filter(pl.col("set_ID") == equip_2pc).collect().to_dicts()
if row:
row_0 = row[0]
self.__mapping_csv_to_attr(row_0)
else:
raise ValueError(f"套装 {equip_2pc} 不存在")
def _init_main_stats(self, drive4: str | None, drive5: str | None, drive6: str | None):
"""初始化主词条"""
drive_parts = [drive4, drive5, drive6]
# 初始化1-3号位
self.HP_numeric += 2200
self.ATK_numeric += 316
self.DEF_numeric += 184
# 匹配4-6号位
for drive in drive_parts:
match drive:
case "生命值%" | "生命值":
self.HP_percent += 0.3
case "攻击力%" | "攻击力":
self.ATK_percent += 0.3
case "防御力%" | "防御力":
self.DEF_percent += 0.48
case "暴击率%" | "暴击率":
if self.crit_balancing:
self.baseCRIT_score += 48
else:
self.CRIT_rate_numeric += 0.24
case "暴击伤害%" | "暴击伤害":
if self.crit_balancing:
self.baseCRIT_score += 48
else:
self.CRIT_damage_numeric += 0.48
case "异常精通":
self.AP_numeric += 92
case "穿透率%" | "穿透率":
self.PEN_ratio += 0.24
case "冰属性伤害%" | "冰属性伤害":
self.ICE_DMG_bonus += 0.3
case "火属性伤害%" | "火属性伤害":
self.FIRE_DMG_bonus += 0.3
case "电属性伤害%" | "电属性伤害":
self.ELECTRIC_DMG_bonus += 0.3
case "以太属性伤害%" | "以太属性伤害":
self.ETHER_DMG_bonus += 0.3
case "物理属性伤害%" | "物理属性伤害":
self.PHY_DMG_bonus += 0.3
case "异常掌控":
self.AM_percent += 0.3
case "冲击力%" | "冲击力":
self.IMP_percent += 0.18
case "能量自动回复%" | "能量自动回复":
self.sp_regen_percent += 0.6
case None:
continue
case "None" | "-" | "" | "0":
continue
case _:
raise ValueError(f"提供的主词条名称 {drive} 不存在")
def _init_sub_stats(
self,
scATK_percent: int | float = 0,
scATK: int | float = 0,
scHP_percent: int | float = 0,
scHP: int | float = 0,
scDEF_percent: int | float = 0,
scDEF: int | float = 0,
scAnomalyProficiency: int | float = 0,
scPEN: int | float = 0,
scCRIT: int | float = 0,
scCRIT_DMG: int | float = 0,
*,
DMG_BONUS: int | float = 0,
PEN_RATIO: int | float = 0,
ANOMALY_MASTERY: int | float = 0,
SP_REGEN: int | float = 0,
):
"""初始化副词条"""
self.ATK_percent += scATK_percent * SUB_STATS_MAPPING["scATK_percent"]
self.ATK_numeric += scATK * SUB_STATS_MAPPING["scATK"]
self.HP_percent += scHP_percent * SUB_STATS_MAPPING["scHP_percent"]
self.HP_numeric += scHP * SUB_STATS_MAPPING["scHP"]
self.DEF_percent += scDEF_percent * SUB_STATS_MAPPING["scDEF_percent"]
self.DEF_numeric += scDEF * SUB_STATS_MAPPING["scDEF"]
self.AP_numeric += scAnomalyProficiency * SUB_STATS_MAPPING["scAnomalyProficiency"]
self.PEN_numeric += scPEN * SUB_STATS_MAPPING["scPEN"]
if self.crit_balancing:
self.baseCRIT_score += (
(scCRIT * SUB_STATS_MAPPING["scCRIT"]) * 2
+ (scCRIT_DMG * SUB_STATS_MAPPING["scCRIT_DMG"])
) * 100
else:
self.CRIT_rate_numeric += scCRIT * SUB_STATS_MAPPING["scCRIT"]
self.CRIT_damage_numeric += scCRIT_DMG * SUB_STATS_MAPPING["scCRIT_DMG"]
# Only for parallel
element_dmg_mapping = {
0: self.PHY_DMG_bonus,
1: self.FIRE_DMG_bonus,
2: self.ICE_DMG_bonus,
3: self.ELECTRIC_DMG_bonus,
4: self.ETHER_DMG_bonus,
5: self.ICE_DMG_bonus, # 烈霜也是冰
6: self.ETHER_DMG_bonus,
}
element_dmg_mapping[self.element_type] += DMG_BONUS * SUB_STATS_MAPPING["DMG_BONUS"]
self.PEN_ratio += PEN_RATIO * SUB_STATS_MAPPING["PEN_RATIO"]
self.AM_percent += ANOMALY_MASTERY * SUB_STATS_MAPPING["ANOMALY_MASTERY"]
self.sp_regen_percent += SP_REGEN * SUB_STATS_MAPPING["SP_REGEN"]
def hardset_sub_stats(
self,
scATK_percent: int | float | None = None,
scATK: int | float | None = None,
scHP_percent: int | float | None = None,
scHP: int | float | None = None,
scDEF_percent: int | float | None = None,
scDEF: int | float | None = None,
scAnomalyProficiency: int | float | None = None,
scPEN: int | float | None = None,
scCRIT: int | float | None = None,
scCRIT_DMG: int | float | None = None,
*,
DMG_BONUS: int | float | None = None,
PEN_RATIO: int | float | None = None,
ANOMALY_MASTERY: int | float | None = None,
SP_REGEN: int | float | None = None,
):
"""硬设置副词条，仅修改传入的参数对应的属性"""
if scATK_percent is not None:
self.ATK_percent = scATK_percent * SUB_STATS_MAPPING["scATK_percent"]
if scATK is not None:
self.ATK_numeric = scATK * SUB_STATS_MAPPING["scATK"]
if scHP_percent is not None:
self.HP_percent = scHP_percent * SUB_STATS_MAPPING["scHP_percent"]
if scHP is not None:
self.HP_numeric = scHP * SUB_STATS_MAPPING["scHP"]
if scDEF_percent is not None:
self.DEF_percent = scDEF_percent * SUB_STATS_MAPPING["scDEF_percent"]
if scDEF is not None:
self.DEF_numeric = scDEF * SUB_STATS_MAPPING["scDEF"]
if scAnomalyProficiency is not None:
self.AP_numeric = scAnomalyProficiency * SUB_STATS_MAPPING["scAnomalyProficiency"]
if scPEN is not None:
self.PEN_numeric = scPEN * SUB_STATS_MAPPING["scPEN"]
if self.crit_balancing:
if scCRIT is not None or scCRIT_DMG is not None:
current_score = self.baseCRIT_score
if scCRIT is not None:
current_score += scCRIT * SUB_STATS_MAPPING["scCRIT"] * 2 * 100
if scCRIT_DMG is not None:
current_score += scCRIT_DMG * SUB_STATS_MAPPING["scCRIT_DMG"] * 100
self.baseCRIT_score = current_score
else:
if scCRIT is not None:
self.CRIT_rate_numeric = scCRIT * SUB_STATS_MAPPING["scCRIT"]
if scCRIT_DMG is not None:
self.CRIT_damage_numeric = scCRIT_DMG * SUB_STATS_MAPPING["scCRIT_DMG"]
# Only for parallel
if DMG_BONUS is not None:
element_dmg_mapping = {
0: "PHY_DMG_bonus",
1: "FIRE_DMG_bonus",
2: "ICE_DMG_bonus",
3: "ELECTRIC_DMG_bonus",
4: "ETHER_DMG_bonus",
5: "ICE_DMG_bonus", # 烈霜也是冰
6: "ETHER_DMG_bonus", # 玄墨也是以太
}
setattr(
self,
element_dmg_mapping[self.element_type],
DMG_BONUS * SUB_STATS_MAPPING["DMG_BONUS"],
)
if PEN_RATIO is not None:
self.PEN_ratio = PEN_RATIO * SUB_STATS_MAPPING["PEN_RATIO"]
if ANOMALY_MASTERY is not None:
self.AM_percent = ANOMALY_MASTERY * SUB_STATS_MAPPING["ANOMALY_MASTERY"]
if SP_REGEN is not None:
self.sp_regen_percent = SP_REGEN * SUB_STATS_MAPPING["SP_REGEN"]
def __init_attr_curve_config(self, parallel_config: ExecAttrCurveCfg):
if not isinstance(parallel_config, ExecAttrCurveCfg):
return
ALLOW_SC_LIST: list[str] = list(SUB_STATS_MAPPING.keys())
sc_name, sc_value = parallel_config.sc_name, parallel_config.sc_value
if sc_name in ALLOW_SC_LIST:
adjust_pair = {sc_name: sc_value}
else:
raise RuntimeError(f"Parallel Config Segfault: sc_name: {sc_name} do not exist")
self.hardset_sub_stats(**adjust_pair)
def update_sp_and_decibel(self, *args, **kwargs):
"""自然更新能量和喧响的方法"""
# Preload Skill
skill_nodes: list[SkillNode] = _skill_node_filter(*args, **kwargs)
for node in skill_nodes:
# SP
self.update_single_node_sp(node)
# SP recovery over time
self.update_sp_overtime(args, kwargs)
def update_sp_overtime(self, args, kwargs):
"""处理当前tick的自然回能"""
sp_regen_data: list[SPUpdateData] = _sp_update_data_filter(*args, **kwargs)
for mul in sp_regen_data:
if mul.char_name == self.NAME:
sp_change_2 = mul.get_sp_regen() / 60 # 每秒回能转化为每帧回能
self.update_sp(sp_change_2)
def update_single_node_sp(self, node):
"""处理单个skill_node的回能"""
if node.char_name == self.NAME:
sp_consume = node.skill.sp_consume
sp_threshold = node.skill.sp_threshold
sp_recovery = node.skill.sp_recovery
if self.sp < sp_threshold:
print(
f"{node.skill_tag}需要{sp_threshold:.2f}点能量，目前{self.NAME}仅有{self.sp:.2f}点，需求无法满足，请检查技能树"
)
sp_change = sp_recovery - sp_consume
self.update_sp(sp_change)
# Decibel
self.process_single_node_decibel(node)
def process_single_node_decibel(self, node):
allowed_list = ["1371_Q_A"]
if (
self.NAME == node.char_name
and node.skill_tag.split("_")[1] == "Q"
and node.skill_tag not in allowed_list
):
if self.decibel - 3000 <= -1e-5:
print(
f"{self.NAME} 释放大招时喧响值不足3000，目前为{self.decibel:.2f}点，请检查技能树"
)
self.decibel = 0
else:
# 计算喧响变化值
decibel_change = node.skill.self_fever_re
# 如果喧响变化值大于0，则更新喧响值
if decibel_change > 0:
# 如果不是自身技能，倍率折半
if node.char_name != self.NAME:
decibel_change *= 0.5
# 更新喧响值
self.update_decibel(decibel_change)
def update_sp(self, sp_value: int | float):
"""可全局强制更新能量的方法"""
self.sp += sp_value
self.sp = max(0.0, min(self.sp, self.sp_limit))
def update_decibel(self, decibel_value: int | float):
"""可外部强制更新喧响的方法"""
# if self.decibel == 3000 and self.NAME == '仪玄':
# print(f"{self.NAME} 释放技能时喧响值已满3000点！")
from zsim.sim_progress.ScheduledEvent.Calculator import cal_buff_total_bonus
dynamic_buff = self.sim_instance.global_stats.DYNAMIC_BUFF_DICT
enabled_buff = tuple(dynamic_buff[self.NAME])
buff_bonus_dict = cal_buff_total_bonus(
enabled_buff=enabled_buff, judge_obj=None, sim_instance=self.sim_instance
)
decibel_get_ratio = buff_bonus_dict.get("喧响获得效率", 0)
final_decibel_change_value = decibel_value * (1 + decibel_get_ratio)
self.decibel += final_decibel_change_value
# print(final_decibel_change_value, decibel_value, decibel_get_ratio)
self.decibel = max(0.0, min(self.decibel, 3000))
def special_resources(self, *args, **kwargs) -> None:
"""父类中不包含默认特殊资源"""
return None
def get_resources(self) -> tuple[str | None, int | float | bool | None]:
"""获取特殊资源的属性名称与数量"""
return None, None
def get_special_stats(self, *args, **kwargs) -> dict[str | None, object | None]:
"""获取全部特殊属性的名称与数值"""
result: dict[str | None, object | None] = {}
return result
def __str__(self) -> str:
return f"{self.NAME} {self.level}级，能量{self.sp:.2f}，喧响{self.decibel:.2f}"
def reset_myself(self):
# 重置能量、喧响值
self.sp: float = 40.0
self.decibel: float = 1000.0
# 重置动态属性
self.dynamic.reset()
def refresh_myself(self):
"""部分角色身上存在每个tick更新一次的数据结构，所以这里提供一个统一的对外调用接口。
目前这个接口是被Schedule阶段调用的。"""
return None
def __deepcopy__(self, memo):
return self
def personal_action_replace_strategy(self, action: str):
return action
def POST_INIT_DATA(self, sim_instance: "Simulator"):
pass
class LastingNode:
def __init__(self, char_instance: Character):
"""用于记录和管理角色持续释放技能的状态节点
该类负责追踪角色的技能释放状态，包括连续释放同一技能的情况和技能被打断的处理。
属性:
char_instance (Character): 关联的角色实例
node (SkillNode): 当前正在执行的技能节点，初始为None
start_tick (int): 开始释放技能的时间点
update_tick (int): 最近一次更新状态的时间点
is_spamming (bool): 是否处于连续释放同一技能的状态
repeat_times (int): 连续释放同一技能的次数
"""
self.char_instance = char_instance
self.node = None
self.start_tick = 0
self.update_tick = 0
self.is_spamming = False # 是否处于连续释放技能的状态
self.repeat_times = 0
def reset(self):
"""重置所有状态参数到初始值
在需要清除当前技能状态时调用，比如切换角色或战斗结束时
"""
self.node = None
self.start_tick = 0
self.update_tick = 0
self.is_spamming = False
self.repeat_times = 0
def update_node(self, node, tick: int):
"""更新技能节点状态
处理技能节点的更新逻辑，包括：
1. 处理与其他角色节点的交互
2. 处理技能被打断的情况
3. 处理连续释放同一技能的状态更新
4. 处理技能切换的逻辑
参数:
node (SkillNode): 新的技能节点
tick (int): 当前时间点
异常:
ValueError: 当尝试过早更新节点时抛出
"""
# 若传入动作不是自己的技能
# from zsim.sim_progress.Preload import SkillNode
# assert isinstance(node, SkillNode)
if node.is_additional_damage and node.skill.ticks == 0:
# 若传入的动作是0帧的附加伤害，由于这些技能很明显是不需要角色通过某些动画动作来释放的，
# 所以这里就不更新lasting_node，以保证不会因为0帧技能而导致lasting_node的数据被污染。
return
if node.char_name != self.char_instance.NAME:
if self.node is None:
# 若此时自己没有技能，则直接返回
return
if self.is_spamming and self.node.end_tick <= tick:
# 若此时自己正在持续释放某技能但是该技能已经结束，则结束技能释放状态、清空技能节点，重置参数；
self.is_spamming = False
self.node = None
self.update_tick = tick
self.repeat_times = 0
return
else:
# 若传入动作是自己的技能
if self.node is None:
# 若此时自己没有登记中的技能，那么就登记当前技能，并且更新参数
self.node = node
self.start_tick = tick
self.update_tick = tick
self.repeat_times = 1
return
# 若此时自己有正在进行中的技能
if node.skill_tag in ["被打断", "发呆"]:
# 若此时技能是“被打断”或是“发呆”，则进行参数更新，并且关闭spamming参数；
self.is_spamming = False
self.node = node
self.start_tick = tick
self.update_tick = tick
self.repeat_times = 0
return
else:
# 若此时传入技能是其他正常技能，则需要进行判断
if self.node.end_tick > tick and node.active_generation:
# 若已经登记的技能尚未结束，且新传入技能是主动释放，那需要进行验错——理论上，APL不会在角色当前尚还有动作时放行一个新技能。
if not self.node.skill.do_immediately and node.skill.do_immediately:
# 若已登记技能并非高优先级，而传入技能为高优先级，则说明是发生了技能顶替（比如大招顶替自己的平A），这是一个正常情况，所以不进入报错分支；
pass
else:
if "dodge" in self.node.skill_tag:
# 若已经登记技能为闪避，那么此时无论传入什么技能，都不进入报错分支——因为闪避是可以被任意取消的
pass
else:
# 其他的情况则说明APL模块确实出现了错误，报错。
raise ValueError(
f"过早传入了node{node.skill_tag}，当前node{self.node.skill_tag}为{self.node.preload_tick}开始 {self.node.end_tick}结束,\n"
f"但是{node.skill_tag}的企图在{tick}tick进行更新，它预计从{node.preload_tick}开始 {node.end_tick}结束！"
)
# 在验错环节结束后，正式进行技能信息的更新、替换；
if self.node.skill_tag == node.skill_tag:
# 若传入技能和已登记技能一致，则直接更新参数
self.is_spamming = True
self.repeat_times += 1
else:
# 若传入技能和已登记技能不一致，则关闭spamming参数，并更新技能信息
self.is_spamming = False
self.start_tick = tick
self.repeat_times = 1
# 无论如何，node以及update_tick参数都会更新
self.node = node
self.update_tick = tick
def spamming_info(self, tick: int):
"""获取当前技能持续释放的状态信息
参数:
tick (int): 当前时间点
返回:
tuple: (是否连续释放中, 技能标签, 持续时间, 重复次数)
"""
lasting_tick = tick - self.start_tick
if self.node is None:
skill_tag = None
else:
skill_tag = self.node.skill_tag
return self.is_spamming, skill_tag, lasting_tick, self.repeat_times
if __name__ == "__main__":
pass
================================================
FILE: zsim/sim_progress/Character/skill_class.py
================================================
import ast
from functools import lru_cache
import polars as pl
from zsim.define import (
CHARACTER_DATA_PATH,
DEFAULT_SKILL_PATH,
SKILL_DATA_PATH,
ElementType,
)
from zsim.sim_progress import Report
try:
# 读取角色数据
char_lf = pl.scan_csv(CHARACTER_DATA_PATH)
except Exception as e:
raise IOError(f"无法读取文件 {CHARACTER_DATA_PATH}: {e}")
@lru_cache(maxsize=64)
def lookup_name_or_cid(name: str = "", cid: int | str | None = None) -> tuple[str, int]:
"""
初始化角色名称和CID（角色ID）。
这个方法用于验证和确定角色的名称和CID。它可以根据提供的名称或CID来查找
对应的角色信息，并确保提供的名称和CID匹配。如果只提供了名称或CID，它将
尝试从 ./data/character.csv 中查找对应的CID或名称。
参数:
- name:str 角色的名称。
- CID:int 角色的ID。
示例：
self.NAME, self.CID = lookup_name_or_cid(name, cid)
返回:
- 一个包含角色名称和CID的元组。
异常:
- ValueError: 提供的名称和CID不匹配，或者角色不存在。
- IOError: 角色数据库常量 CHARACTER_DATA_PATH 有误
- SystemError: 无法处理提供的参数。
"""
global char_lf
# 查找角色信息
if name != "":
result = char_lf.filter(pl.col("name") == name).collect().to_dicts()
elif cid is not None:
# 确保cid是整数
cid_int = int(cid) if cid is not None else None
result = char_lf.filter(pl.col("CID") == cid_int).collect().to_dicts()
else:
raise ValueError("角色名称与ID必须至少提供一个")
if not result:
raise ValueError("角色不存在")
character_info = result[0]
# 检查传入的name与CID是否匹配
if name is not None and cid is not None:
if int(character_info["CID"]) != int(cid):
raise ValueError("传入的name与CID不匹配")
return character_info["name"], int(character_info["CID"])
class Skill:
def __init__(
self,
name: str = "",
CID: int | str | None = None,
normal_level=12,
special_level=12,
dodge_level=12,
chain_level=12,
assist_level=12,
core_level=6,
char_obj=None,
):
"""
根据提供的角色、各技能等级，创建一个角色的技能对象。
成功创建的对象会包含角色的名称、ID、核心技等级、包含全部技能的字典
skills_dict：
-keys: 该角色的全部技能标签（skill_tag）
-values: 包含全部属性的 InitSkill 对象，可使用getattr()方法调用
方法 __create_action_list():
-检查 self.skill_dict 中是否包含闪避、正向切人、反向切人、被打断、发呆
-有，则使用自身的技能
-没有，则使用自带 module，初始化这些动作
-返回仅包含动作名称的列表
方法 get_skill_info()：
-在仅输入技能标签（skill_tag）时，返回该技能的 InitSkill 对象
-在同时输入技能标签（skill_tag）和所需属性时（attr_info)时，返回该技能对象的指定属性
以下两个标识符必须提供至少一个：\n
name:str 角色名称\n
CID:int 角色的ID
调用示例：
test_object = Skill(name='艾莲')
action_list = test_object.action_list # 获取动作列表
skills_dict = test_object.skills_dict # 获取技能字典
skill_0: Skill.InitSkill = test_object.skills_dict[action_list[0]] # 获取第一个动作对应的技能对象
skill_0.damage_ratio # 获取第一个动作的伤害倍率—方式1
test_object.get_skill_info(skill_tag=action_list[0], attr_info='damage_ratio') # 获取第一个动作的伤害倍率-方式2
"""
# 初始化时确保CID被转换为整数或None
cid_int = int(CID) if CID is not None else None
# 初始化角色名称和CID
self.name, self.CID = lookup_name_or_cid(name, cid_int)
# 核心技等级需要可读
self.core_level = core_level
self.skill_level_dict = {
"normal": normal_level,
"special": special_level,
"dodge": dodge_level,
"chain": chain_level,
"assist": assist_level,
"core": core_level,
} # 技能等级字典
# 最晚在这里创建DataFrame，优化不一点点，这玩意可大了
schema_dict = {
"CID": int,
"name": str,
"CN_TriggerLevel": str,
"skill_tag": str,
"CN_skill_tag": str,
"skill_text": str,
"INSTRUCTION": str,
"damage_ratio": float,
"damage_ratio_growth": float,
"D_LEVEL12": float,
"D_LEVEL14": float,
"D_LEVEL16": float,
"stun_ratio": float,
"stun_ratio_growth": float,
"S_LEVEL12": float,
"S_LEVEL14": float,
"S_LEVEL16": float,
"sp_threshold": int,
"sp_consume": int,
"sp_recovery": float,
"adrenaline_recovery": float,
"adrenaline_threshold": float,
"adrenaline_consume": float,
"fever_recovery": float,
"self_fever_re": float,
"distance_attenuation": int,
"initial_level": int,
"anomaly_accumulation": float,
"skill_type": int,
"trigger_buff_level": int,
"element_type": int,
"element_damage_percent": float,
"diff_multiplier": float,
"ticks": int,
"hit_times": int,
"on_field": bool,
"anomaly_attack": bool,
"interruption_resistance": int,
"swap_cancel_ticks": int,
"labels": str,
"follow_up": str,
"follow_by": str,
"aid_direction": int,
"aid_lag_ticks": int,
"tick_list": str,
"force_add_condition_APL": str,
"heavy_attack": bool,
"max_repeat_times": int,
"do_immediately": bool,
"anomaly_update_list": str,
}
all_skills_lf = pl.scan_csv(SKILL_DATA_PATH, schema_overrides=schema_dict)
# 根据CID提取角色的技能数据
try:
self.skill_df = all_skills_lf.filter(pl.col("CID") == self.CID).collect()
# 如果没有找到对应CID，则报错
if self.skill_df.is_empty():
raise ValueError(f"找不到CID为 {self.CID} 的角色信息")
# 提取dataframe中，每个索引为skill_tag的值，保存为keys
else:
__keys = self.skill_df["skill_tag"].unique()
except KeyError:
print(f"{SKILL_DATA_PATH} 中缺少 'skill_tag' 列") # 虽然不可能
return
except ValueError as e:
print(e)
return
# 创建技能字典与技能列表 self.skills_dict 与 self.action_list
self.skills_dict = {} # {技能名str:技能参数object:InitSkill}
self.char_obj = char_obj
for key in __keys:
skill = self.InitSkill(
skill_dataframe=self.skill_df,
key=key,
normal_level=normal_level,
special_level=special_level,
dodge_level=dodge_level,
chain_level=chain_level,
assist_level=assist_level,
core_level=core_level,
CID=self.CID,
char_name=self.name,
char_obj=self.char_obj,
)
self.skills_dict[key] = skill
self.action_list = self.__create_action_list()
def get_skill_info(self, skill_tag: str, attr_info: str | None = None):
"""
-在仅输入技能标签（skill_tag）时，返回该技能的 InitSkill 对象\n
-在同时输入技能标签（skill_tag）和所需属性时（attr_info)时，返回该技能对象的指定属性
"""
skill_info: Skill.InitSkill = self.skills_dict[skill_tag]
if attr_info is None:
return skill_info
else:
value = getattr(skill_info, attr_info)
if value:
return value
else:
return None
def __create_action_list(self):
"""
创建动作列表并检查初始化状态
此函数旨在为角色或实体创建一个动作列表，并检查这些动作是否已经初始化。
它通过检查技能字典（skills_dict）中的键来确定哪些动作已经存在，如果不存在（即未初始化），
则会创建这些动作的默认实例。
"""
# 定义需要检查是否初始化的动作列表
default_actions_dataframe = pl.read_csv(DEFAULT_SKILL_PATH)
by_default_actions = default_actions_dataframe["skill_tag"].unique()
# 初始化每个动作的状态为 True
init_actions = {action: True for action in by_default_actions}
# 遍历 skills_dict 的键
for key in self.skills_dict.keys():
# 检查键中是否包含某个动作
for action in by_default_actions:
if action in key:
# 如果包含，则将对应动作的状态设为 False
init_actions[action] = False
# 遍历每个动作及其初始化状态
for action, init in init_actions.items():
# 如果某个动作未被初始化，则创建对应的 Skill 对象并添加到 skills_dict
if init:
self.skills_dict[f"{self.CID}_{action}"] = Skill.InitSkill(
default_actions_dataframe,
key=action,
char_name=self.name,
CID=self.CID,
char_obj=self.char_obj,
)
return list(self.skills_dict.keys())
class InitSkill:
def __init__(
self,
skill_dataframe: pl.DataFrame,
key,
char_name: str,
normal_level=12,
special_level=12,
dodge_level=12,
chain_level=12,
assist_level=12,
core_level=6,
CID=0,
char_obj=None,
):
"""
初始化角色的单个技能。
会在执行class Skill的时候自动调用，不用手动创建此类的对象
继承自此类的对象会包含输入的技能（key）的全部属性
"""
self.char_obj = char_obj
# 提取数据库内，该技能的数据
_raw_skill_data = skill_dataframe.filter(pl.col("skill_tag") == key).to_dicts()
if not _raw_skill_data:
raise ValueError("未找到技能")
else:
_raw_skill_data = _raw_skill_data[0]
# 如果不是 攻击力/生命值/防御力/精通 倍率，报错，未来可接复杂逻辑
self.diff_multiplier = int(_raw_skill_data["diff_multiplier"])
if _raw_skill_data["diff_multiplier"] not in [0, 1, 2, 3, 4]:
raise ValueError("目前只支持 攻击力/生命值/防御力/精通/贯穿力 倍率")
self.char_name: str = char_name
# 储存技能Tag
self.cid = CID
self.skill_tag = f"{CID}_{key}" if str(CID) not in key else key
self.CN_skill_tag: str = _raw_skill_data["CN_skill_tag"]
self.skill_text: str = _raw_skill_data["skill_text"]
# 确定使用的技能等级
self.skill_type: int = int(_raw_skill_data["skill_type"])
self.skill_level: int = self.__init_skill_level(
self.skill_type,
normal_level,
special_level,
dodge_level,
chain_level,
assist_level,
core_level,
)
# 确定伤害倍率
damage_ratio = float(_raw_skill_data["damage_ratio"])
damage_ratio_growth = float(_raw_skill_data["damage_ratio_growth"])
self.damage_ratio: float = damage_ratio + damage_ratio_growth * (self.skill_level - 1)
# 确定失衡倍率
stun_ratio = float(_raw_skill_data["stun_ratio"])
stun_ratio_growth = float(_raw_skill_data["stun_ratio_growth"])
self.stun_ratio: float = stun_ratio + stun_ratio_growth * (self.skill_level - 1)
# 能量相关属性
self.sp_threshold: float = float(_raw_skill_data["sp_threshold"])
self.sp_consume: float = float(_raw_skill_data["sp_consume"])
self.sp_recovery: float = float(_raw_skill_data["sp_recovery"])
# 闪能相关——仪玄专属
self.adrenaline_threshold: float = float(_raw_skill_data["adrenaline_threshold"])
self.adrenaline_consume: float = float(_raw_skill_data["adrenaline_consume"])
self.adrenaline_recovery: float = float(_raw_skill_data["adrenaline_recovery"])
# 喧响值
self.self_fever_re: float = float(_raw_skill_data["self_fever_re"])
# 距离衰减，不知道有啥用
self.distance_attenuation: int = int(_raw_skill_data["distance_attenuation"])
# 属性异常蓄积值，直接转化为浮点
self.anomaly_accumulation: float = float(_raw_skill_data["anomaly_accumulation"]) / 100
# TriggerBuffLevel
self.trigger_buff_level: int = int(_raw_skill_data["trigger_buff_level"])
# 元素相关
self.element_type: ElementType = _raw_skill_data["element_type"]
self.element_damage_percent: float = float(_raw_skill_data["element_damage_percent"])
# 动画相关
ticks_str = _raw_skill_data["ticks"]
if ticks_str is None or ticks_str == "test":
print(f"检测到技能 {self.skill_tag}的ticks参数不正确，已设置为默认值60")
self.ticks = 60
else:
self.ticks: int = int(_raw_skill_data["ticks"])
temp_hit_times = int(_raw_skill_data["hit_times"])
self.hit_times: int = temp_hit_times if temp_hit_times > 0 else 1
self.on_field: bool = bool(_raw_skill_data["on_field"])
self.anomaly_attack: bool = bool(_raw_skill_data["anomaly_attack"])
# 特殊标签
labels_str = _raw_skill_data["labels"]
if labels_str is None or not str(labels_str).strip(): # 判断空值或空字符串
labels = None
else:
# 去除首尾空格后尝试解析字典
labels = ast.literal_eval(str(labels_str).strip())
self.labels: dict | None = labels # 技能特殊标签
# if self.labels:
# pass
# TODO：抗打断标签；无敌标签
# 技能链相关
__swap_cancel_ticks_value = _raw_skill_data["swap_cancel_ticks"]
if __swap_cancel_ticks_value is None:
self.swap_cancel_ticks = 0
else:
self.swap_cancel_ticks: int = int(
_raw_skill_data["swap_cancel_ticks"]
) # 可执行合轴操作的最短时间
follow_up = _raw_skill_data["follow_up"]
if follow_up is None:
self.follow_up: list = []
else:
self.follow_up: list = _raw_skill_data["follow_up"].split(
"|"
) # 技能发动后强制衔接的技能标签
follow_by = _raw_skill_data["follow_by"]
if follow_by is None:
self.follow_by: list = []
else:
self.follow_by: list = _raw_skill_data["follow_by"].split(
"|"
) # 发动技能必须的前置技能标签
self.aid_direction: int = _raw_skill_data["aid_direction"] # 触发快速支援的方向
aid_lag_ticks_value = _raw_skill_data["aid_lag_ticks"]
if aid_lag_ticks_value == "inf":
self.aid_lag_ticks = self.ticks - 1
elif aid_lag_ticks_value is None:
self.aid_lag_ticks = 0
else:
self.aid_lag_ticks: int = int(
_raw_skill_data["aid_lag_ticks"]
) # 技能激活快速支援的滞后时间
tick_value = _raw_skill_data["tick_list"]
if tick_value is None:
self.tick_list = None
elif isinstance(tick_value, str):
# 处理空字符串或纯空格
if not tick_value.strip():
self.tick_list = None
else:
try:
# 转换并去除首尾空格
self.tick_list = ast.literal_eval(str(tick_value).strip())
# self.tick_list = [int(v.strip()) for v in split_values]
except ValueError as e:
raise ValueError(f"{self.skill_tag} 的 tick_list 包含无效整数: {e}")
else:
# 处理非字符串类型（如意外数值）
self.tick_list = None
if self.tick_list:
if max(self.tick_list) >= self.ticks:
raise ValueError(
f"{self.skill_tag}的精确帧数分布的最大值超过技能总帧数！请检查数据正确性，{self.tick_list, self.ticks}"
)
if len(self.tick_list) != self.hit_times:
raise ValueError(
f"{self.skill_tag}的精确帧数分布所包含的命中数与技能的命中总数不符！请检查数据正确性，{self.tick_list, self.hit_times}"
)
self.ratio_distribution: list | None = None # 技能的精确倍率分布
# _raw_skill_data['ratio_distribution'].split(':') if _raw_skill_data['ratio_distribution'] else None
self.force_add_condition_APL = []
condition_value = _raw_skill_data["force_add_condition_APL"]
if condition_value is None:
self.force_add_condition_APL = []
else:
from zsim.sim_progress.Preload.apl_unit.APLUnit import (
SimpleUnitForForceAdd,
)
condition_list = condition_value.strip().split(";")
for _cond_str in condition_list:
_cond_list = _cond_str.strip().split("|")
simple_apl_unit_for_force_add = SimpleUnitForForceAdd(condition_list=_cond_list)
self.force_add_condition_APL.append(simple_apl_unit_for_force_add)
if (
len(self.follow_up) != len(self.force_add_condition_APL)
and self.force_add_condition_APL
):
raise ValueError(
f"ID为{self.skill_tag}的技能的follow_up与force_add_condition_APL长度不一致！请检查数据正确性"
)
self.skill_attr_dict = {
attr: getattr(self, attr)
for attr in dir(self)
if not attr.startswith("__") and not callable(getattr(self, attr))
}
self.heavy_attack: bool = bool(_raw_skill_data["heavy_attack"])
__max_repeat_times_value = _raw_skill_data["max_repeat_times"]
if __max_repeat_times_value is None:
self.max_repeat_times = 1
else:
self.max_repeat_times: int = int(
_raw_skill_data["max_repeat_times"]
) # 最大重复释放次数。
"""
技能是否立刻执行，大部分技能都是False，目前只有QTE和大招具有这种属性。
该属性会在APL部分的SwapCancelEngine中被用到，用于检测角色已有的动作是否会被新动作打断。
"""
self.do_immediately: bool = bool(_raw_skill_data["do_immediately"])
self.anomaly_update_rule: (
list[int] | int | None
) = [] # 更新异常的模式，如果不填，那就是最后一跳，如果有填写，那就按照填写的跳数来更新。
anomaly_update_list_str = _raw_skill_data["anomaly_update_list"]
self._process_anomaly_update_rule(anomaly_update_list_str)
Report.report_to_log(f"[Skill INFO]:{self.skill_tag}:{str(self.skill_attr_dict)}")
def _process_anomaly_update_rule(self, anomaly_update_list_str):
"""
初始化 异常更新规则 ：
1、不填，则就返回[]，那就按照最后一跳处理；
2、-1，则返回-1，那就按照每一跳处理；
3、a&b&c&d， 则返回[a, b, c, d]，那就按照这些跳数处理
"""
if anomaly_update_list_str is None:
self.anomaly_update_rule = [] # None代表更新节点是最后一跳
else:
try:
anomaly_update_mode = int(anomaly_update_list_str)
if anomaly_update_mode == -1:
self.anomaly_update_rule = anomaly_update_mode
else:
if anomaly_update_mode > self.hit_times:
raise ValueError(
f"{self.skill_tag}的更新节点大于技能总帧数！请检查数据正确性"
)
self.anomaly_update_rule = [anomaly_update_mode]
except ValueError:
self.anomaly_update_rule = anomaly_update_list_str.split("&")
if (
isinstance(self.anomaly_update_rule, list)
and len(self.anomaly_update_rule) > self.hit_times
):
raise ValueError(f"{self.skill_tag}的更新节点总数大于技能总帧数！请检查数据正确性")
@staticmethod
def __init_skill_level(
skill_type: int,
normal_level: int,
special_level: int,
dodge_level: int,
chain_level: int,
assist_level: int,
core_level: int,
) -> int:
"""
根据 skill_type 选择对应的技能等级
参数:
- skill_type (int): 技能类型标签
- normal_level (int): 普攻等级
- special_level (int): 特殊技等级
- dodge_level (int): 闪避等级
- chain_level (int): 连携技等级
- assist_level (int): 支援技等级
- core_level (int): 核心被动等级
"""
skill_levels = {
0: normal_level,
1: special_level,
2: dodge_level,
3: chain_level,
4: core_level,
5: assist_level,
6: assist_level, # 暂时过度一下，防止报错
}
# FIXME：修复数据库中支援技skill_type的问题！
if skill_type in skill_levels:
return skill_levels[skill_type]
else:
raise ValueError(f"非法的技能种类（skill_type）：{skill_type}")
def __str__(self) -> str:
return self.skill_tag
def __str__(self) -> str:
return self.name + "Skills"
if __name__ == "__main__":
test_object = Skill(name="艾莲")
test_object2 = Skill(CID=1221)
action_list = test_object.action_list # 获取动作列表
skills_dict = test_object.skills_dict # 获取技能字典
skill_0: Skill.InitSkill = test_object.skills_dict[
action_list[0]
] # 获取第一个动作对应的技能对象
print(skill_0.damage_ratio) # 获取第一个动作的伤害倍率
print(
test_object.get_skill_info(skill_tag=action_list[0], attr_info="damage_ratio")
) # 获取第一个动作的伤害倍率
================================================
FILE: zsim/sim_progress/Character/utils/__init__.py
================================================
================================================
FILE: zsim/sim_progress/Character/utils/filters.py
================================================
from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import NewAnomaly
from zsim.sim_progress.data_struct import SPUpdateData
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator
def _skill_node_filter(*args, **kwargs) -> list["SkillNode"]:
"""过滤出输入的 SKillNode，并作为列表返回"""
from zsim.sim_progress.Preload import SkillNode
skill_nodes: list[SkillNode] = []
for arg in args:
if isinstance(arg, SkillNode):
skill_nodes.append(arg)
for value in kwargs.values():
if isinstance(value, SkillNode):
skill_nodes.append(value)
return skill_nodes
def _multiplier_filter(*args, **kwargs) -> list[Calculator.MultiplierData]:
"""过滤出输入的 乘区数据，并作为列表返回"""
from zsim.sim_progress.ScheduledEvent.Calculator import Calculator
multiplier_data: list[Calculator.MultiplierData] = []
for arg in args:
if isinstance(arg, Calculator.MultiplierData):
multiplier_data.append(arg)
for value in kwargs.values():
if isinstance(value, Calculator.MultiplierData):
multiplier_data.append(value)
return multiplier_data
def _sp_update_data_filter(*args, **kwargs) -> list["SPUpdateData"]:
"""过滤出输入的 SPUpdateData，并作为列表返回"""
from zsim.sim_progress.data_struct import SPUpdateData
sp_update_data: list[SPUpdateData] = []
for arg in args:
if isinstance(arg, SPUpdateData):
sp_update_data.append(arg)
for value in kwargs.values():
if isinstance(value, SPUpdateData):
sp_update_data.append(value)
return sp_update_data
def _anomaly_filter(*args, **kwargs) -> list["NewAnomaly"]:
"""过滤出输入的异常类！并作为列表返回"""
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import NewAnomaly
anomaly_bar_list: list[NewAnomaly] = []
for arg in args:
if isinstance(arg, NewAnomaly):
anomaly_bar_list.append(arg)
for value in kwargs.values():
if isinstance(value, NewAnomaly):
anomaly_bar_list.append(value)
return anomaly_bar_list
================================================
FILE: zsim/sim_progress/Dot/BaseDot.py
================================================
from dataclasses import dataclass
from typing import TYPE_CHECKING
from zsim.sim_progress.anomaly_bar import AnomalyBar
if TYPE_CHECKING:
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
class Dot:
def __init__(
self,
bar: "AnomalyBar | None",
skill_tag: str | None = None,
sim_instance: "Simulator | None" = None,
):
self.sim_instance = sim_instance
self.ft = self.DotFeature(sim_instance=self.sim_instance)
self.dy = self.DotDynamic()
self.history = self.DotHistory()
# 默认情况下不创建anomlay_data。
self.anomaly_data = None
self.skill_node_data: "SkillNode | None" = None
if bar is not None and skill_tag is not None:
raise ValueError("Dot的构造函数不可以同时传入bar和skill_tag")
if bar:
self.anomaly_data = bar
if skill_tag:
from zsim.sim_progress.Buff import JudgeTools
from zsim.sim_progress.Preload.SkillsQueue import spawn_node
if self.sim_instance is None:
raise ValueError("sim_instance is None, but it should not be.")
preload_data = JudgeTools.find_preload_data(sim_instance=self.sim_instance)
tick = JudgeTools.find_tick(sim_instance=self.sim_instance)
self.skill_node_data = spawn_node(skill_tag, tick, preload_data.skills)
@dataclass
class DotFeature:
"""
这里记录了Dot的固定属性。
effect_rules属性记录了dot的更新规则。
更新指的是：更新自身时间、层数、内置CD等属性，同时也有可能是造成伤害。
0：无更新——只有效果，没有更新机制。
1：根据时间更新——完全依赖内置CD
2：命中时更新——依赖内置CD，同时需要外部进行“hit”判断，外部函数或许需要联动LoadingMission和TimeTick
3：缓存式更新——依赖内置CD，以及Dot.Dynamic中的动态记录模块，来记录伤害积累。
4：碎冰——只有含有重攻击的技能在end标签处才能触发。
"""
sim_instance: "Simulator | None"
update_cd: int | float = 0
index: str | None = None
name: str | None = None
dot_from: str | None = None
effect_rules: int | None = None
max_count: int | None = None
max_duration: int | None = None
incremental_step: int | None = None
max_effect_times: int = 30
count_as_skill_hit: bool = (
False # dot生效时的伤害能否视作技能的一次命中（从而参与其他的命中类dot的触发）
)
complex_exit_logic = False # 复杂的结束判定
def __str__(self):
return str(self.__dict__)
@dataclass
class DotDynamic:
start_ticks: int = 0
end_ticks: int = 0
last_effect_ticks: int = 0
active: bool | None = None
count: int = 0
ready: bool | None = None
effect_times: int = 0
@dataclass
class DotHistory:
start_times: int = 0
end_times: int = 0
last_start_ticks: int = 0
last_end_ticks: int = 0
last_duration: int = 0
def ready_judge(self, timenow: int):
if not self.dy.ready:
if timenow - self.dy.last_effect_ticks >= self.ft.update_cd:
self.dy.ready = True
def end(self, timenow: int):
self.dy.active = False
self.dy.count = 0
self.history.last_end_ticks = timenow
self.history.last_duration = timenow - self.dy.start_ticks
self.history.end_times += 1
def start(self, timenow: int):
self.dy.active = True
self.dy.start_ticks = timenow
self.dy.last_effect_ticks = timenow
if self.ft.max_duration is None:
raise ValueError(f"{self.ft.index}的最大持续时间为None，请检查初始化！")
self.dy.end_ticks = self.dy.start_ticks + self.ft.max_duration
self.history.start_times += 1
self.history.last_start_ticks = timenow
self.dy.count = 1
self.dy.effect_times = 1
self.dy.ready = False
def exit_judge(self, **kwargs) -> bool:
pass
================================================
FILE: zsim/sim_progress/Dot/Dots/AliceCoreSkillAssaultDot.py
================================================
from dataclasses import dataclass
from typing import TYPE_CHECKING
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class AliceCoreSkillAssaultDot(Dot):
def __init__(self, bar: "AnomalyBar | None" = None, sim_instance: "Simulator | None" = None):
super().__init__(bar=bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(sim_instance=sim_instance)
if sim_instance is None:
raise ValueError("构造dot实例时必须传入有效的sim_instance实例")
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
# 正确性验证
if any(
[
bar is None,
bar is not None and not isinstance(bar, AnomalyBar),
bar.element_type != 0,
]
):
raise ValueError(
"构造爱丽丝的核心被动Dot实例时，必须传入有效的 物理属性 anomlay_bar 实例"
)
self.anomaly_data = bar
self.anomaly_data.rename_tag = "爱丽丝强击Dot"
self.anomaly_data.scaling_factor = 0.025 # 缩放比例
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
update_cd: int | float = 57 # dot的内置CD是0.95秒，换算为57帧
index: str | None = "AliceCoreSkillAssaultDot"
name: str | None = "爱丽丝物理异常Dot"
dot_from: str | None = "爱丽丝"
effect_rules: int | None = 1
max_count: int | None = 999999
incremental_step: int | None = 1
max_duration: int | None = 999999
complex_exit_logic = True # 该dot为复杂退出逻辑
def exit_judge(self, **kwargs):
"""爱丽丝物理异常Dot 的退出逻辑：敌人的只要不处于畏缩状态，就退出。"""
enemy = kwargs.get("enemy", None)
from zsim.sim_progress.Enemy import Enemy
if not isinstance(enemy, Enemy):
raise TypeError("enemy参数必须是Enemy类的实例")
if not enemy.dynamic.assault:
self.dy.active = False
return True
return False
================================================
FILE: zsim/sim_progress/Dot/Dots/AuricInkCorruption.py
================================================
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class AuricInkCorruption(Dot):
def __init__(self, bar: "AnomalyBar | None", sim_instance: "Simulator | None"):
super().__init__(bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(sim_instance=sim_instance)
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
char_name_box: list[str] = field(init=False)
update_cd: int | float = 30
index: str | None = "AuricInkCorruption"
name: str | None = "玄墨侵蚀"
dot_from: str | None = "enemy"
effect_rules: int | None = 2
max_count: int | None = 1
incremental_step: int | None = 1
max_duration: int | None = 600
max_effect_times = 30
def __post_init__(self):
if self.sim_instance is None:
raise ValueError("sim_instance is None, but it should not be.")
self.char_name_box = self.sim_instance.init_data.name_box
"""
如果某角色在角色列表里，侵蚀和最大生效次数就要发生变化。
"""
if "某角色" in self.char_name_box:
self.max_duration = 600 + 180
================================================
FILE: zsim/sim_progress/Dot/Dots/Corruption.py
================================================
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class Corruption(Dot):
def __init__(self, bar: "AnomalyBar | None" = None, sim_instance: "Simulator | None" = None):
super().__init__(bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(sim_instance=sim_instance)
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
char_name_box: list[str] = field(init=False)
update_cd: int | float = 30
index: str | None = "Corruption"
name: str | None = "侵蚀"
dot_from: str | None = "enemy"
effect_rules: int | None = 2
max_count: int | None = 1
incremental_step: int | None = 1
max_duration: int | None = None
max_effect_times: int = 30
def __post_init__(self):
if self.sim_instance is None:
raise ValueError("sim_instance is None, but it should not be.")
self.char_name_box = self.sim_instance.init_data.name_box
self.max_duration = 600
"""
如果某角色在角色列表里，侵蚀和最大生效次数就要发生变化。
"""
if "某角色" in self.char_name_box:
self.max_duration = 600 + 180
================================================
FILE: zsim/sim_progress/Dot/Dots/Freez.py
================================================
from dataclasses import dataclass
from typing import TYPE_CHECKING
import numpy as np
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class Freez(Dot):
def __init__(self, bar: "AnomalyBar | None" = None, sim_instance: "Simulator | None" = None):
super().__init__(bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(sim_instance=sim_instance)
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
enemy = None
update_cd: int | float = np.inf
index: str | None = "Freez"
name: str | None = "冻结"
dot_from: str | None = "enemy"
effect_rules: int | None = 4
max_count: int | None = 1
incremental_step: int | None = 1
max_duration: int | None = None
max_effect_times: int = 1
def __post_init__(self):
if self.sim_instance is None:
raise ValueError("sim_instance is None, but it should not be.")
self.enemy = self.sim_instance.schedule_data.enemy
self.max_duration = int(240 * (1 + self.enemy.freeze_resistance))
def start(self, timenow: int):
self.dy.active = True
self.dy.start_ticks = timenow
self.dy.last_effect_ticks = timenow
if self.ft.max_duration is not None:
self.dy.end_ticks = self.dy.start_ticks + self.ft.max_duration
self.history.start_times += 1
self.history.last_start_ticks = timenow
self.dy.count = 1
self.dy.effect_times = 1
self.dy.ready = True
================================================
FILE: zsim/sim_progress/Dot/Dots/Ignite.py
================================================
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class Ignite(Dot):
"""
灼烧dot，固定时间，内置CD0.5s
"""
def __init__(self, bar: "AnomalyBar | None" = None, sim_instance: "Simulator | None" = None):
super().__init__(bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(
sim_instance=sim_instance
) # 用Ignite的DotFeature替代默认的DotFeature
# 你可以在这里添加特定于Ignite的行为或方法
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
char_name_box: list[str] = field(init=False)
update_cd: int | float = 30
index: str | None = "Ignite"
name: str | None = "灼烧"
dot_from: str | None = "enemy"
effect_rules: int | None = 1
max_count: int | None = 1
incremental_step: int | None = 1
max_duration: int | None = None
max_effect_times: int = 30
def __post_init__(self):
if self.sim_instance is None:
raise ValueError("sim_instance is None, but it should not be.")
self.char_name_box = self.sim_instance.global_stats.name_box
"""
如果柏妮思在角色列表里，灼烧和最大生效次数就要发生变化。
"""
if "柏妮思" in self.char_name_box:
self.max_duration = 600 + 180
else:
self.max_duration = 600
================================================
FILE: zsim/sim_progress/Dot/Dots/Shock.py
================================================
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class Shock(Dot):
def __init__(self, bar: "AnomalyBar | None" = None, sim_instance: "Simulator | None" = None):
super().__init__(bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(sim_instance=sim_instance)
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
char_name_box: list[str] = field(init=False)
exist_buff_dict: dict[str, dict[str, object]] = field(init=False)
update_cd: int | float = 60
index: str | None = "Shock"
name: str | None = "感电"
dot_from: str | None = "enemy"
effect_rules: int | None = 2
max_count: int | None = 1
incremental_step: int | None = 1
"""
如果丽娜在角色列表里，灼烧和最大生效次数就要发生变化。
"""
max_duration: int | None = None
max_effect_times: int = 30
def __post_init__(self):
if self.sim_instance is None:
raise ValueError("sim_instance is None, but it should not be.")
self.char_name_box = self.sim_instance.init_data.name_box
self.exist_buff_dict = self.sim_instance.load_data.exist_buff_dict
if "丽娜" in self.char_name_box:
if "Buff-角色-丽娜-组队被动-延长感电" in self.exist_buff_dict["丽娜"]:
self.max_duration = 600 + 180
else:
self.max_duration = 600
else:
self.max_duration = 600
================================================
FILE: zsim/sim_progress/Dot/Dots/ViviansProphecy.py
================================================
from dataclasses import dataclass
from typing import TYPE_CHECKING
from zsim.sim_progress.Buff import JudgeTools
from zsim.sim_progress.Preload.SkillsQueue import spawn_node
from .. import Dot
if TYPE_CHECKING:
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.simulator.simulator_class import Simulator
class ViviansProphecy(Dot):
def __init__(self, bar: "AnomalyBar | None" = None, sim_instance: "Simulator | None" = None):
super().__init__(bar=bar, sim_instance=sim_instance) # 调用父类Dot的初始化方法
self.ft = self.DotFeature(sim_instance=sim_instance)
if sim_instance is None:
raise ValueError("构造dot实例时必须传入有效的sim_instance实例")
self.preload_data = JudgeTools.find_preload_data(sim_instance=sim_instance)
tick = JudgeTools.find_tick(sim_instance=sim_instance)
self.skill_node_data = spawn_node("1331_Core_Passive", tick, self.preload_data.skills)
@dataclass
class DotFeature(Dot.DotFeature):
sim_instance: "Simulator | None"
update_cd: int | float = 33
index: str | None = "ViviansProphecy"
name: str | None = "薇薇安的预言"
dot_from: str | None = "薇薇安"
effect_rules: int | None = 1
max_count: int | None = 999999
incremental_step: int | None = 1
max_duration: int | None = 999999
complex_exit_logic = True # 该dot为复杂退出逻辑
def exit_judge(self, **kwargs):
"""薇薇安的预言 dot的退出逻辑：敌人只要处于异常状态，就不会退出。"""
enemy = kwargs.get("enemy", None)
from zsim.sim_progress.Enemy import Enemy
if not isinstance(enemy, Enemy):
raise TypeError("enemy参数必须是Enemy类的实例")
if not enemy.dynamic.is_under_anomaly():
self.dy.active = False
return True
return False
================================================
FILE: zsim/sim_progress/Dot/Dots/__init__.py
================================================
================================================
FILE: zsim/sim_progress/Dot/__init__.py
================================================
from .BaseDot import Dot
class DotNode:
def __init__(self):
pass
__all__ = ["Dot", "DotNode"]
================================================
FILE: zsim/sim_progress/Enemy/EnemyAttack/EnemyAttackClass.py
================================================
import ast
from collections import defaultdict
from typing import TYPE_CHECKING
import numpy as np
import pandas as pd
from zsim.define import (
ENEMY_ATK_PARAMETER_DICT,
ENEMY_ATTACK_ACTION,
ENEMY_ATTACK_METHOD_CONFIG,
ENEMY_ATTACK_REPORT,
ENEMY_RANDOM_ATTACK,
ENEMY_REGULAR_ATTACK,
)
from zsim.sim_progress.RandomNumberGenerator import RNG
if TYPE_CHECKING:
from zsim.sim_progress.Enemy import Enemy
"""
EnemyAttack模块相关的数据结构以及程序逻辑设计如下（2025.1.30）：
1、新建一个数据库（暂时用CSV来执行），里面记录了Enemy的各种进攻动作，由独立的ID作为索引。（包含了默认动作）
2、新建一个Json，用来记录不同敌人的进攻策略，其中包含了各种数据库中的动作ID，以及它们对应的几率。（包含了默认的策略）
Json的键值是一个独立的ID，可以是数字，也可以是字符串。
3、在Enemy类下，更新一个新的字段（包括EnemyClass以及对应的Enemy.csv），用来存放不同敌人的策略ID，
4、初始化时，根据Enemy.attack.策略ID→对应的攻击策略→对应的攻击动作ID（多个）→构造EnemyAttack实例（多个）→存放到Enemy.attack.attack_method下
4.1、每个攻击动作都会构造一个单独的EnemyAttackAction实例，这些实例会被存到EnemyAttackMethod实例下，并且有各自的几率。
5、调用时，利用EnemyAttack.attack_event_spawn函数，生成本次发生的攻击事件，并且抛出，被Preload获取。
"""
method_file = pd.read_csv(ENEMY_ATTACK_METHOD_CONFIG, index_col="ID")
action_file = pd.read_csv(ENEMY_ATTACK_ACTION, index_col="ID")
class EnemyAttackMethod:
"""含有若干个进攻动作的进攻策略"""
def __init__(self, ID: int = 0, enemy_instance: "Enemy" = None):
self.action_set: dict[float | int, EnemyAttackAction] = defaultdict()
self.enemy = enemy_instance
self.active = True
if ENEMY_RANDOM_ATTACK:
self.random_attack: bool = True
self.attack_skill_tag = None
elif ENEMY_REGULAR_ATTACK:
self.random_attack = False
self.attack_skill_tag = EnemyAttackAction(ID=int(method_file.loc[ID]["action_set"])).tag
else:
self.random_attack = False
self.attack_skill_tag = None
self.active = False
self.last_start_tick = 0
self.last_end_tick = 0
self.ready = False
rate_list = method_file.loc[ID]["action_rate"].split("|")
if sum(float(i) for i in rate_list) > 1:
raise ValueError("动作总权重超过1，请检查配置")
single_action_id_list = method_file.loc[ID]["action_set"].split("|")
if len(rate_list) != len(single_action_id_list):
raise ValueError("动作总数与概率总数不符，请检查配置")
self.rest_tick = method_file.loc[ID]["rest_tick"]
self.description = method_file.loc[ID]["discription"] # FIXME
self.name = method_file.loc[ID]["method_name"]
for i in range(len(single_action_id_list)):
action_id = single_action_id_list[i]
action_rate = float(rate_list[i])
enemy_attack_action = EnemyAttackAction(int(action_id))
self.action_set[action_rate] = enemy_attack_action
if ENEMY_ATTACK_REPORT:
print(f"【进攻交互系统初始化】：为敌人添加进攻动作：{enemy_attack_action}")
if ENEMY_ATTACK_REPORT:
print("【进攻交互系统初始化】：敌人进攻动作初始化完毕！")
print(
f"【进攻交互系统初始化】：敌人（{self.enemy.name}）共拥有{len(self.action_set)}个进攻动作，每次进攻决策的冷却时间为：{self.rest_tick}tick！"
)
if not self.active and ENEMY_ATTACK_REPORT:
print(
"【进攻交互系统初始化】：由于在配置文件中并未开启任意一种进攻策略，所以在本次模拟中敌人不会进攻！"
)
def ready_check(self, current_tick: int) -> bool:
"""判断敌人进攻的内置CD——进攻动作结束后，进攻决策才会进入冷却时间。"""
if not self.ready:
if current_tick - self.last_end_tick >= self.rest_tick:
self.ready = True
return self.ready
def probablity_driven_action_selection(self, current_tick: int) -> "EnemyAttackAction | None":
"""根据概率选择一个进攻动作"""
cumulative_probability = (
0 # 累积概率，这个数字没有实际意义，只是为了方便计算，每次函数运行时都初始化为0
)
rng: RNG = self.enemy.sim_instance.rng_instance
normalized_value = rng.random_float()
if not self.ready_check(current_tick):
return None
for _rate, _action in self.action_set.items():
cumulative_probability += _rate
if cumulative_probability >= normalized_value:
self.last_start_tick = current_tick
self.last_end_tick = current_tick + _action.duration
self.ready = False
return _action
else:
"""如果循环结束，还没有选中任何一个动作，说明无事发生，返回None"""
return None
def time_anchored_action_selection(self, current_tick: int) -> "EnemyAttackAction | None":
"""以固定的时间间隔选择固定的进攻动作"""
if self.ready_check(current_tick=current_tick):
self.last_start_tick = current_tick
self.last_end_tick = current_tick + self.action_set[1].duration
self.ready = False
if ENEMY_ATTACK_REPORT:
self.enemy.sim_instance.schedule_data.change_process_state()
print(
f"{self.enemy.name}（ID：{self.enemy.index_ID}）抛出进攻动作{self.action_set[1].tag}"
)
return self.action_set[1]
else:
return None
def reset_myself(self):
"""重构EnemyAttack方法！"""
self.last_start_tick = 0
self.last_end_tick = 0
self.ready = False
class EnemyAttackAction:
"""敌人的单个进攻动作，它不记录任何动态数据，只是一个静态的动作数据结构，"""
def __init__(self, ID: int):
if ID == 0:
raise ValueError("EnemyAttackAction实例化所用的ID为0，请检查配置信息！")
self.id = ID
self.action_dict = action_file.loc[ID].to_dict()
self.tag = self.action_dict.get("tag", "")
self.description = self.action_dict.get("description", "")
self.hit = int(self.action_dict.get("hit", 0))
if self.hit <= 0:
raise ValueError("hit参数必须大于0，请检查配置信息！")
self.duration = float(self.action_dict.get("duration", 0))
if self.duration <= 0:
raise ValueError("duration参数必须大于0，请检查配置信息！")
self.cd = int(self.action_dict.get("cd", 0))
hit_list_str = self.action_dict.get("hit_list", None)
if hit_list_str is None or hit_list_str is np.nan:
# 在未提供hit_list的情况下，默认hit均匀分布，所以直接根据hit和duration来产生hit_list，
self.hit_list = list(
(self.duration / (self.hit + 1)) * (i + 1) for i in range(int(self.hit))
)
else:
self.hit_list = ast.literal_eval(hit_list_str)
if len(self.hit_list) != self.hit:
raise ValueError(f"{self.tag}的命中数量与命中时间列表长度不符，请检查配置信息！")
self.parryable = bool(self.action_dict.get("blockable", True)) # 是否可以招架
self.interruption_level_list = self.action_dict.get("interruption_level_list", None)
if self.interruption_level_list is None or self.interruption_level_list is np.nan:
self.interruption_level_list = [1] * self.hit
else:
self.interruption_level_list = self.interruption_level_list.split("|")
self.effect_radius_list = self.action_dict.get("effect_radius_list", None)
# TODO：暂时不考虑由技能范围不同而对命中率造成的影响，统一按照100%命中来处理，
self.stoppable = self.action_dict.get("stoppable", True)
self.hit_type = self.action_dict.get("hit_type", "Light")
if self.hit_type == "Chain" and self.hit <= 1:
raise ValueError(
f"{self.tag}为连续进攻动作，但是其命中数量为{self.hit}，请检查配置信息！"
)
if self.hit_type in ["Light", "Heavy"] and self.hit > 1:
raise ValueError(
f"{self.tag}为{self.hit_type}攻击，但是其命中数量为{self.hit}，请检查配置信息！"
)
def get_hit_tick(self, another_ta: int = None, hit_count: int = 1) -> int:
"""获取命中时间，"""
if not self.hit_list:
raise ValueError("hit_list为空，无法获取命中点！")
hit_tick = self.hit_list[hit_count - 1]
Ta = ENEMY_ATK_PARAMETER_DICT.get("Taction") if another_ta is None else another_ta
if hit_tick < Ta:
raise ValueError(
f"{self.tag}的第一个命中点({hit_tick})小于响应动作持续时间({Ta})，请检查数据库！"
)
return self.hit_list[0]
def get_first_hit(self) -> int:
"""获取第一个命中点"""
if not self.hit_list:
raise ValueError("hit_list为空，无法获取第一个命中点！")
first_hit_tick = self.hit_list[0]
Ta = ENEMY_ATK_PARAMETER_DICT.get("Taction")
if first_hit_tick < Ta:
raise ValueError(
f"{self.tag}的第一个命中点({first_hit_tick})小于相应动作持续时间({Ta})，请检查数据库！"
)
return self.hit_list[0]
def __str__(self):
return f"进攻动作ID：{self.id}, 技能Tag：{self.tag}，动作耗时：{self.duration}，单次动作的冷却时间：{self.cd}"
if __name__ == "__main__":
method = EnemyAttackMethod()
print(f"{method.name},{method.description}")
count = 0
for rate, action in method.action_set.items():
print(
f"事件{count + 1}，几率{rate}，动作集{action.hit_list}，是否可被格挡：{action.blockable_list}，\n打断等级{action.interruption_level_list}，效果半径{action.effect_radius_list}，是否可被打断{action.stoppable}"
)
count += 1
================================================
FILE: zsim/sim_progress/Enemy/EnemyAttack/__init__.py
================================================
from .EnemyAttackClass import EnemyAttackMethod
__all__ = ["EnemyAttackMethod"]
================================================
FILE: zsim/sim_progress/Enemy/EnemyUniqueMechanic/BaseUniqueMechanic.py
================================================
from abc import ABC, abstractmethod
class BaseUniqueMechanic(ABC):
@abstractmethod
def __init__(self, enemy_instance):
self.enemy = enemy_instance
@abstractmethod
def update_myself(self, *args, **kwargs):
pass
@abstractmethod
def event_active(self, *args, **kwargs):
pass
================================================
FILE: zsim/sim_progress/Enemy/EnemyUniqueMechanic/BreakingLegManager.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.data_struct import SingleHit
from zsim.sim_progress.Report import report_dmg_result
from .BaseUniqueMechanic import BaseUniqueMechanic
if TYPE_CHECKING:
from zsim.sim_progress.Enemy import Enemy
"""
FOCUS_RATIO_MAP 的存在，是为了模拟角色在破腿的过程中，
伤害溢散到别的腿上，导致单腿的破腿效率低于预期的情况。
但是，这种伤害的溢散，本质上和角色自身的技能模组有关。
这里的数据往往来自于对实战视频的观察，并非准确数值，并且可能经常需要调整。
"""
class BreakingLegManager:
def __init__(self, enemy_instance):
self.leg_group = {
0: SingleLeg(enemy_instance, self),
1: SingleLeg(enemy_instance, self),
2: SingleLeg(enemy_instance, self),
3: SingleLeg(enemy_instance, self),
4: SingleLeg(enemy_instance, self),
5: SingleLeg(enemy_instance, self),
}
self.major_target = 0
self.FOCUS_RATIO_MAP = {1361: 0.6, 1381: 0.6}
self.enemy = enemy_instance
def update_myself(self, single_hit: SingleHit, tick: int):
"""这是整个manager的对外总接口，负责接收SingleHit，并且分配伤害到对应的腿上"""
leg_index_tuple = self.select_target()
char_cid = int(single_hit.skill_tag.strip().split("_")[0])
major_ratio = self.FOCUS_RATIO_MAP.get(char_cid, 0.7)
minor_ratio = (1 - major_ratio) / 2
ratio_tuple = (minor_ratio, major_ratio, minor_ratio)
for i in range(len(leg_index_tuple)):
self.leg_group[leg_index_tuple[i]].update_myself(single_hit, tick, ratio_tuple[i])
def select_target(self) -> tuple[int, int, int]:
"""选腿！"""
major_target = self.major_target
minor_target_left = self.major_target - 1
if minor_target_left < 0:
minor_target_left = 5
minor_target_right = self.major_target + 1
if minor_target_right > 5:
minor_target_right = 0
return minor_target_left, major_target, minor_target_right
def change_major_leg(self):
"""换一条腿！"""
self.major_target += 1
if self.major_target > 5:
self.major_target = 0
# print(f'换腿！当前主目标为{self.major_target}！')
def report_all_legs(self):
print("------------------")
for index, legs in self.leg_group.items():
print(f"腿{index}的已损失HP为{legs.lost_leg_hp}")
print("------------------")
def reset_myself(self):
self.major_target = 0
for index, leg in self.leg_group.items():
leg.reset_single_leg()
class SingleLeg(BaseUniqueMechanic):
"""
这是一个关于未知侵蚀复合体的破腿机制的模拟结构——
这只怪拥有六条腿，每条腿都有自己的独立血量，
它们的对外接口是：update_myself()函数，需要传入single_hit，
而它们的事件触发核心是：event_active()函数
"""
def __init__(self, enemy_instance, manager_instance):
super().__init__(enemy_instance)
self.leg_hp_ratio = 0.08 # 腿的倍率
self.max_leg_hp = self.enemy.max_HP * self.leg_hp_ratio
self.lost_leg_hp = 0 # 已经损失的腿的HP
self.cd = 180 # 给了破腿的CD，暂定3秒
self.last_broken = 0 # 上一次破腿的时间
self.event = BreakingEvent(enemy_instance)
self.manager = manager_instance
def update_myself(self, single_hit: SingleHit, tick: int, ratio: float):
"""对外接口，接受主动技能的SingleHit，并且积累伤害。但是这里有几种情况是不积累伤害的，"""
if self.enemy.dynamic.stun:
"""
敌人如果正处于失衡状态下，那么游戏会强制锁定你的目标为敌人本体，而非腿，
所以在失衡期，是不太容易破腿的，
在模拟器中，我们对这种情况进行了直接返回的处理——即模拟战斗中，失衡期不会破腿。
不尽如此，腿还会因为失衡期而恢复。
"""
if self.lost_leg_hp != 0:
self.restore_leg()
return
if self.last_broken != 0:
if tick - self.last_broken <= self.cd:
"""腿还没冷却好！"""
return
"""更新腿的生命值"""
self.update_leg_hp(single_hit, tick, ratio)
def event_active(self, single_hit: SingleHit, tick: int):
self.event.active(single_hit, tick)
def broken_leg_judge(self, tick: int) -> bool:
"""检测腿有没有爆"""
if self.lost_leg_hp >= self.max_leg_hp:
self.last_broken = tick
self.restore_leg()
print("腿破了！！！")
return True
else:
return False
def restore_leg(self):
self.lost_leg_hp = 0
self.manager.change_major_leg()
def update_leg_hp(self, single_hit: SingleHit, tick: int, ratio):
"""更新腿的生命值"""
self.lost_leg_hp += single_hit.dmg_expect * ratio
if self.broken_leg_judge(tick):
self.event_active(single_hit, tick)
self.enemy.sim_instance.decibel_manager.update(single_hit=single_hit, key="part_break")
def reset_single_leg(self):
"""重置单条腿"""
self.lost_leg_hp = 0
self.last_broken = 0
class BreakingEvent:
def __init__(self, enemy_instance):
self.enemy: "Enemy" = enemy_instance
self.decibel_rewards = 1000 # 奖励喧响值
self.stun_ratio = 0.15 # 失衡比例
self.damage_ratio = 0.055 # 破腿的直伤倍率
self.game_state = None
self.found_char_dict: dict[int:object] = {}
def active(self, single_hit: SingleHit, tick: int):
"""破腿进行时！"""
if self.game_state is None:
from zsim.sim_progress.Preload import get_game_state
self.game_state = get_game_state()
# 1、更新喧响值
self.update_decibel(single_hit)
# 2、更新失衡
stun_value = self.enemy.max_stun * self.stun_ratio
self.enemy.update_stun(stun_value)
self.enemy.stun_judge(tick, single_hit=single_hit)
# 3、更新伤害
dmg_value = self.enemy.max_HP * self.damage_ratio
self.enemy._Enemy__HP_update(dmg_value)
report_dmg_result(
tick=tick,
element_type=0,
skill_tag="破腿",
dmg_expect=round(dmg_value, 2),
dmg_crit=round(dmg_value, 2),
stun=round(stun_value, 2),
buildup=0,
**self.enemy.dynamic.get_status(),
)
def update_decibel(self, single_hit: SingleHit):
"""向破腿的角色里更新喧响值"""
char_cid = int(single_hit.skill_tag.strip().split("_")[0])
if char_cid not in self.found_char_dict:
from zsim.sim_progress.Buff import find_char_from_CID
self.found_char_dict[char_cid] = find_char_from_CID(char_cid, self.enemy.sim_instance)
char_obj = self.found_char_dict[char_cid]
char_name = char_obj.NAME
from zsim.sim_progress.data_struct import ScheduleRefreshData
refresh_data = ScheduleRefreshData(
sp_target=(char_name,),
decibel_target=(char_name,),
decibel_value=self.decibel_rewards,
)
self.game_state["schedule_data"].event_list.append(refresh_data)
================================================
FILE: zsim/sim_progress/Enemy/EnemyUniqueMechanic/__init__.py
================================================
from .BreakingLegManager import BreakingLegManager
UNIQUE_MECHANIC_MAP = {
11411: BreakingLegManager,
# 11412: BreakingLegManager,
11413: BreakingLegManager,
# 11414: BreakingLegManager,
}
def unique_mechanic_factory(enemy_instance):
"""构造特殊敌人事件的工厂函数"""
mechanic_class = UNIQUE_MECHANIC_MAP.get(enemy_instance.index_ID, None)
if mechanic_class:
return mechanic_class(enemy_instance)
else:
return None
================================================
FILE: zsim/sim_progress/Enemy/QTEManager/QTEData.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.data_struct import SingleHit
if TYPE_CHECKING:
from zsim.sim_progress.Enemy import Enemy
class QETDataUpdater:
@classmethod
def apply(cls, qte_data, single_qte, attr_name):
raise NotImplementedError
class SumStrategy(QETDataUpdater):
"""数值累加策略"""
@classmethod
def apply(cls, qte_data, single_qte, attr_name):
single_qte_value = getattr(single_qte, attr_name, 0) or 0
qte_data_value = getattr(qte_data, attr_name, 0) or 0
setattr(qte_data, attr_name, single_qte_value + qte_data_value)
class ListMergeStrategy(QETDataUpdater):
"""列表合并策略"""
@classmethod
def apply(cls, qte_data, single_qte, attr_name):
single_qte_value = getattr(single_qte, attr_name, []) or []
qte_data_value = getattr(qte_data, attr_name, []) or []
setattr(qte_data, attr_name, qte_data_value + single_qte_value)
class QTEData:
def __init__(self, enemy_instance):
"""这个数据结构是管理怪物的QTE的总体数据的，它会随着Enemy类的初始化而一同初始化。
其中的动态数据（比如qte_received_box qte_triggered_times等，会在每次进入失衡期之前进行重置。"""
self.enemy_instance: "Enemy" = enemy_instance # 在初始化时，传入Enemy实例；
self.qte_received_box: list[str] = [] # 用于接受QTE阶段输入的QTE skill_tag
self.qte_triggered_times: int = 0 # 已经触发过几次QTE了
self.qte_triggerable_times: int | None = (
enemy_instance.QTE_triggerable_times
) # 最多可以触发几次QTE
self.qte_activation_available = False # 彩色失衡阶段——在StunJudge中被打开，在SingeQTE的merge方法中被关闭，当然，失衡阶段的结束也会关闭该参数（依旧是StunJudge）。
self.single_qte = None # 单次QTE的实例
self.__single_hit_check = lambda hit: all(
[
hit.hitted_count == 1
or hit.heavy_hit # 第一跳、重击（通常为重攻击标签的最后一跳）均能通过判定，
# hit.proactive or (not hit.proactive and 'QTE' in hit.skill_tag), # 筛选出主动技能，所有的被动释放的技能都不能和QTE的激活行为进行互动。
]
)
self.strategies_map = {
"qte_received_box": ListMergeStrategy,
"qte_triggered_times": SumStrategy,
}
self.preload_data = None
self.qte_answered_box: list[str | None] = [] # 响应过QTE的角色
def check_myself(self, single_hit: SingleHit | None = None) -> bool:
"""该函数用于检查自身目前的状态，即当前是彩色失衡还是灰色失衡；"""
if self.qte_triggerable_times is None:
return False
if self.qte_triggered_times > self.qte_triggerable_times:
raise ValueError(
f"QTE的实际响应总次数为{self.qte_triggered_times}次，大于其最大次数{self.qte_triggerable_times}次！"
)
if len(self.qte_received_box) > self.qte_triggered_times:
raise ValueError(
f"QTE总计包含了{len(self.qte_received_box)}个skill_tag，而实际的响应次数为{self.qte_triggered_times}次！"
)
if self.enemy_instance.dynamic.stun:
if self.qte_triggerable_times is None:
return False
if self.qte_triggered_times < self.qte_triggerable_times:
return True
else:
self.qte_activation_available = False
return False
else:
"""
v0.3.1b2更新：
为了复现柚叶2画在非失衡期也能激发一次连携技的机制，
所以为single_hit以及skill_node添加了一个新参数——force_qte_trigger（强制激发QTE）
该参数可以让QTE管理器在非失衡期放行这个single_hit，并且使其顺利进入后续的判定。
后续更新：
QTE结构仅需要针对两种情况进行特殊放行：
1、在非失衡期能够激发连携的skill_node——force_qte_trigger==True
2、在非失衡期激发连携后，进行响应的QTE技能；
"""
if self.single_qte is None:
if single_hit is not None:
if single_hit.force_qte_trigger:
return True
else:
if single_hit is not None:
if (
single_hit.skill_node
and single_hit.skill_node.skill.trigger_buff_level == 5
):
return True
return False
def try_qte(self, hit: SingleHit) -> None:
"""
该函数是QTEData的最外层接口，是核心调用函数。
其核心作用为：用传入的SingleHit来尝试激发QTE。
"""
# 0、 如果是非失衡状态或是灰色失衡状态，那么直接返回
if not self.check_myself(single_hit=hit):
return
# 1、可行性审查，这里，只有主动动作的第一跳、以及含有重击标签的、主动动作的最后一跳能够通过判定。
if not self.single_hit_filter(hit):
return
# 2、是否存在已经激活的SingleQTE实例——连携阶段已经因重攻击而激发、SingleQTE实例也已经创建，但是尚未传入SingleHit的状态
if self.single_qte is not None:
if not isinstance(self.single_qte, SingleQTE):
raise TypeError(
f"QTEData的single_qte属性不是SingleQTE类！你往里放入了{type(self.single_qte)}！"
)
# 2.1、尝试将已经通过可行性检查的SingleHit传入到SingleQTE中，进行数据更新，
self.single_qte.receive_hit(hit)
# print(f'{hit.skill_tag}响应了本次连携技触发！')
else:
# 3、如果SingleQTE实例不存在，那么要对传入的SingHit进行判断；
if self.qte_active_selector(hit):
# 3.1、如果是能够激发连携的hit，而此时又没有SingleHit存在，那么就是激活了新的QTE阶段，进入下一步判断。
self.single_qte = SingleQTE(self, single_hit=hit)
self.enemy_instance.sim_instance.schedule_data.change_process_state()
assert hit.skill_node is not None
print(
f"{hit.skill_node.char_name} 的 {hit.skill_node.skill.skill_text} 激发了连携技！当前已经激发过{self.qte_triggered_times + 1}次连携技！"
)
else:
"""
如果不是重攻击，那就只能是某技能的第一跳。
很明显，在SingleHit并未被创建的时候，技能的第一跳并不能激发连携状态。所以这个分支什么都不做（暂时）
这个分枝往往发生在：怪物已经失衡，但是重攻击标签还未传入时，可能是前台切人合轴了，也可能是角色的APL本来就不打连携技。
此时，下一个循环，函数就会触发隔壁分枝，因为有一个SingleQTE是待传入状态，
"""
# print(f'虽然是彩色失衡状态，但是没有进行响应')
return
def single_hit_filter(self, hit: SingleHit):
"""
该函数用于对传入的SingleHit进行筛选，并返回筛选结果。
"""
return self.__single_hit_check(hit)
def reset(self):
"""该函数用于在失衡期开始时的重置QTEdata中的动态数据"""
self.qte_received_box = []
self.qte_triggered_times = 0
self.qte_activation_available = True
self.single_qte = None
self.qte_answered_box = []
def restore(self):
self.qte_received_box = []
self.qte_triggered_times = 0
self.qte_activation_available = False
self.single_qte = None
def spawn_single_qte(self):
pass
def qte_active_selector(self, _hit: SingleHit) -> bool:
"""
这个函数筛选的是真正能激发QTE的技能，这种技能有两个条件：
1、重攻击Hit——含有重攻击标签（“heavy_attack”）的技能的最后一跳
2、函数接收到这个hit信号的同时，角色正处于被操作状态下
（解释一下，这里为什么不用“前台”属性来进行判断：因为绝区零已经存在多名角色同时处于前台的情况，
所以这个“前台”的说法并不准确，但是无论如何，玩家操纵的角色始终只有一名，
所以“角色正处于被操作状态下”才是更准确的描述。）
"""
if not _hit.heavy_hit:
return False
if self.preload_data is None:
self.preload_data = self.enemy_instance.sim_instance.preload.preload_data
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
if not isinstance(self.preload_data, PreloadData):
raise TypeError("QTEData的preload_data属性不是PreloadData类！")
if not self.enemy_instance.dynamic.stun:
assert _hit.skill_node is not None
if _hit.skill_node.force_qte_trigger:
# FIXME: 临时解决方案，理论上2画触发连携技需要柚叶在前台，合轴会导致激发失败；
# 但是这涉及到的底层逻辑较为复杂，APL也不太好改，所以这里暂时先这么临时解决一下
return True
if self.preload_data.operating_now is None:
"""说明目前没有任何角色在前台"""
return False
else:
return int(_hit.skill_tag.split("_")[0]) == self.preload_data.operating_now
def check_qte_legality(self, qte_skill_tag: str):
"""
检查QTE是否合法，即是否已经被响应过了。
"""
CID = int(qte_skill_tag.split("_")[0])
return CID not in self.qte_answered_box
class SingleQTE:
def __init__(self, qte_data: QTEData, single_hit: SingleHit):
self.qte_data = qte_data
self.qte_received_box: list[str] = [] # 用于接受QTE阶段输入的QTE skill_tag
self.qte_triggerable_times: int | None = (
self.qte_data.qte_triggerable_times
) # 最多可以触发几次QTE
self.qte_triggered_times: int = 0 # 已经响应了几次QTE
self.qte_activation_available = False # 彩色失衡阶段
self.__is_hitted = (
False # 每个SingleHit都只会被响应一次，所以这里用一个bool变量来标记是否已经被响应过。
)
self.active_by: SingleHit = single_hit
def receive_hit(self, _single_hit: SingleHit):
"""SingleQTE接收SingleHit的方法"""
if self.__is_hitted:
raise ValueError(
"SingleQTE实例已经响应过一次了！请检查函数逻辑，查找为何处会多次调用同一个SingleQTE的_receive_hit函数！"
)
if not isinstance(_single_hit, SingleHit):
raise TypeError(
f"SingleQTE实例的_receive_hit函数被调用时，传入的single_hit参数不是SingleHit类！而是{type(_single_hit)}！"
)
if _single_hit.hitted_count != 1: # 如果传进来的不是第一跳，那直接return
return
if not _single_hit.proactive: # 如果传进来的是一个非主动动作，也直接return
return
if self.qte_data.enemy_instance.dynamic.stun:
"""正常的QTE接收逻辑"""
self.receive_hit_while_stun(_single_hit)
else:
"""非失衡阶段的QTE接收逻辑（强制触发的QTE）"""
self.receive_qte_without_stun(_single_hit)
def receive_hit_while_stun(self, _single_hit: SingleHit):
"""失衡期接收QTE的业务逻辑"""
self.qte_triggered_times += 1
assert _single_hit.skill_node is not None
if "QTE" not in _single_hit.skill_tag:
"""说明QTE被取消了"""
self.qte_data.enemy_instance.sim_instance.schedule_data.change_process_state()
print(
f"【QTE事件】{_single_hit.skill_node.char_name} 取消第{self.qte_data.qte_triggered_times + 1}次QTE，并释放了 {_single_hit.skill_node.skill.skill_text} "
)
# 当取消QTE时，连续响应QTE的角色列表需要清空
self.qte_data.qte_answered_box = []
else:
"""角色响应了QTE，释放连携技"""
assert self.active_by.skill_node is not None
if _single_hit.skill_node.char_name == self.active_by.skill_node.char_name:
raise ValueError(f"{_single_hit.skill_node.char_name} 企图响应自己激发的QTE！")
self.qte_received_box.append(_single_hit.skill_tag)
"""QTE成功响应之后，返还1秒QTE时间"""
self.qte_data.enemy_instance.sim_instance.schedule_data.change_process_state()
self.qte_data.enemy_instance.dynamic.stun_tick_feed_back_from_QTE += 60
print(
f"【QTE事件】 {_single_hit.skill_node.char_name} 响应了连携，释放连携技（skill_tag为{_single_hit.skill_tag})，返还1秒失衡时间！"
)
# 当角色响应了QTE时，需要将角色的skill_tag添加到qte_answered_box中
CID = _single_hit.skill_node.skill.char_obj.CID
if CID in self.qte_data.qte_answered_box:
raise ValueError(
f"一轮连续地QTE中，每名角色只允许响应一次QTE！当前轮次QTE中，已经有{self.qte_data.qte_answered_box}响应过了QTE，{CID} 企图响应QTE两次！"
)
self.qte_data.qte_answered_box.append(_single_hit.skill_node.skill.char_obj.CID)
self.__is_hitted = True
self.merge_single_qte()
def merge_single_qte(self):
"""SingleQTE向QTEData更新数据的方法"""
for attr_name, strategy in self.qte_data.strategies_map.items():
if hasattr(self, attr_name):
strategy.apply(self.qte_data, self, attr_name)
self.qte_data.single_qte = None
self.qte_data.check_myself()
def receive_qte_without_stun(self, _single_hit: SingleHit):
"""在非失衡阶段接收hit"""
assert _single_hit.skill_node is not None
if "QTE" not in _single_hit.skill_tag:
"""说明QTE被取消了"""
self.qte_data.enemy_instance.sim_instance.schedule_data.change_process_state()
print(
f"【QTE事件】{_single_hit.skill_node.char_name} 取消了强制触发的QTE，并释放了 {_single_hit.skill_node.skill.skill_text} "
)
else:
"""角色响应了QTE，释放连携技"""
assert self.active_by.skill_node is not None
if (
_single_hit.skill_node.char_name == self.active_by.skill_node.char_name
and not self.active_by.skill_node.force_qte_trigger
):
raise ValueError(f"{_single_hit.skill_node.char_name} 企图响应自己激发的QTE！")
# FIXME：由于柚叶2画有强行在非失衡期触发连携技的特性，为了系统稳定暂时让这个激发在后台也能生效。
# 所以这里的验错也需要避开这个情况，否则就会报“自己响应自己QTE”的错误
self.qte_data.enemy_instance.sim_instance.schedule_data.change_process_state()
print(
f"【QTE事件】 {_single_hit.skill_node.char_name} 响应了强制触发的连携，释放连携技 {_single_hit.skill_node.skill.skill_text}（skill_tag为{_single_hit.skill_tag})"
)
self.__is_hitted = True
self.merge_single_qte()
================================================
FILE: zsim/sim_progress/Enemy/QTEManager/__init__.py
================================================
from .QTEData import QTEData
class QTEManager:
def __init__(self, enemy_instance):
self.qte_data: QTEData = QTEData(enemy_instance)
def receive_hit(self, hit):
self.qte_data.try_qte(hit)
def reset_myself(self):
self.qte_data.reset()
def check_qte_legality(self, qte_skill_tag: str):
return self.qte_data.check_qte_legality(qte_skill_tag)
================================================
FILE: zsim/sim_progress/Enemy/__init__.py
================================================
from typing import TYPE_CHECKING, Literal
import numpy as np
import pandas as pd
from zsim.define import ENEMY_ADJUSTMENT_PATH, ENEMY_DATA_PATH
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from zsim.models.event_enums import SpecialStateUpdateSignal as SSUS
from zsim.sim_progress.anomaly_bar import (
AuricInkAnomaly,
ElectricAnomaly,
EtherAnomaly,
FireAnomaly,
FrostAnomaly,
IceAnomaly,
PhysicalAnomaly,
)
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.sim_progress.data_struct import SingleHit
from zsim.sim_progress.data_struct.enemy_special_state_manager import SpecialStateManager
from zsim.sim_progress.Report import report_to_log
from .EnemyAttack import EnemyAttackMethod
from .EnemyUniqueMechanic import unique_mechanic_factory
from .QTEManager import QTEManager
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class EnemySettings:
def __init__(self):
self.enemy_info_overwrite = False # 是否强制覆盖怪物数据
self.forced_no_stun = False
self.forced_no_anomaly = False
self.forced_stun_DMG_take_ratio: float = 1.5
self.forced_anomaly: int = 0
class Enemy:
def __init__(
self,
*,
name: str | None = None,
index_id: int | None = None,
sub_ID: int | None = None,
adjustment_id: int | None = None,
difficulty: float = 1,
sim_instance: "Simulator | None" = None,
):
"""
根据数据库信息创建怪物属性对象。
三选一参数:（你不填也行，默认创建尼尼微作为木桩怪，因为她全部0抗性）
- enemy_name (str): 敌人的中文名称
- enemy_index_ID (int): 敌人的索引ID
- enemy_sub_ID (int): 敌人的子ID，格式为9000+索引ID
!!!注意!!!因为可能存在重名敌人的问题，使用中文名称查找怪物时，只会查找ID最靠前的那一个
更新参数接口：
hit_received(single_hit)
update_stun(float)
获取临时参数接口：
get_hp_percentage()
get_stun_percentage()
"""
# 读取敌人数据文件，初始化敌人信息
assert sim_instance is not None
self.sim_instance: "Simulator" = sim_instance
self.__last_stun_increase_tick: int | None = None
_raw_enemy_dataframe = pd.read_csv(ENEMY_DATA_PATH)
_raw_enemy_adjustment_dataframe = pd.read_csv(ENEMY_ADJUSTMENT_PATH)
# !!!注意!!!因为可能存在重名敌人的问题，使用中文名称查找怪物时，只会返回ID更靠前的
enemy_info = self.__lookup_enemy(_raw_enemy_dataframe, name, index_id, sub_ID)
self.name, self.index_ID, self.sub_ID, self.data_dict = enemy_info
self.adjustment_id = adjustment_id
# 获取调整倍率
self.enemy_adjust: dict[
Literal["生命值", "攻击力", "失衡值上限", "防御力", "异常积蓄值上限"], float
] = self.__lookup_enemy_adjustment(_raw_enemy_adjustment_dataframe, adjustment_id)
# 难度
self.difficulty: float = difficulty
# 初始化动态属性
self.dynamic = self.EnemyDynamic(self)
# 初始化敌人基础属性
self.base_max_HP: float = float(self.data_dict["70级最大生命值"])
self.max_HP: float = (
float(self.data_dict["70级最大生命值"]) * (1 + self.enemy_adjust["生命值"]) * difficulty
)
self.max_ATK: float = float(self.data_dict["70级最大攻击力"]) * (
1 + self.enemy_adjust["攻击力"]
)
self.max_stun: float = float(self.data_dict["70级最大失衡值上限"]) * (
1 + self.enemy_adjust["失衡值上限"]
)
self.max_DEF: float = float(self.data_dict["60级及以上防御力"]) * (
1 + self.enemy_adjust["防御力"]
)
self.CRIT_damage: float = float(self.data_dict["暴击伤害"])
self.able_to_be_stunned: bool = bool(self.data_dict["能否失衡"])
self.able_to_get_anomaly: bool = bool(self.data_dict["能否异常"])
self.stun_recovery_rate: float = float(self.data_dict["失衡恢复速度"]) / 60
self.stun_recovery_time: float = 0.0
self.qte_manager: QTEManager | None = None
self.stun_DMG_take_ratio: float = float(self.data_dict["失衡易伤值"])
self.QTE_triggerable_times: int = int(self.data_dict["可连携次数"])
# 初始化敌人异常状态抗性
max_element_anomaly, self.max_anomaly_PHY = self.__init_enemy_anomaly(
self.able_to_get_anomaly,
self.QTE_triggerable_times,
self.enemy_adjust["异常积蓄值上限"],
)
self.max_anomaly_ICE = self.max_anomaly_FIRE = self.max_anomaly_ETHER = (
self.max_anomaly_ELECTRIC
) = self.max_anomaly_FIREICE = self.max_anomaly_AURICINK = max_element_anomaly
# 初始化敌人其他防御属性
self.interruption_resistance_level: int = int(self.data_dict["抗打断等级"])
self.freeze_resistance: float = float(self.data_dict["冻结抵抗"])
# 伤害抗性
self.ICE_damage_resistance: float = float(self.data_dict["冰伤害抗性"])
self.FIRE_damage_resistance: float = float(self.data_dict["火伤害抗性"])
self.ELECTRIC_damage_resistance: float = float(self.data_dict["电伤害抗性"])
self.ETHER_damage_resistance: float = float(self.data_dict["以太伤害抗性"])
self.PHY_damage_resistance: float = float(self.data_dict["物理伤害抗性"])
# 异常抗性
self.ICE_anomaly_resistance: float = float(self.data_dict["冰异常抗性"])
self.FIRE_anomaly_resistance: float = float(self.data_dict["火异常抗性"])
self.ELECTRIC_anomaly_resistance: float = float(self.data_dict["电异常抗性"])
self.ETHER_anomaly_resistance: float = float(self.data_dict["以太异常抗性"])
self.PHY_anomaly_resistance: float = float(self.data_dict["物理异常抗性"])
# 失衡抗性
self.ICE_stun_resistance: float = float(self.data_dict["冰失衡抗性"])
self.FIRE_stun_resistance: float = float(self.data_dict["火失衡抗性"])
self.ELECTRIC_stun_resistance: float = float(self.data_dict["电失衡抗性"])
self.ETHER_stun_resistance: float = float(self.data_dict["以太失衡抗性"])
self.PHY_stun_resistance: float = float(self.data_dict["物理失衡抗性"])
# 各抗性对应字典
self.damage_resistance_dict: dict[int, float] = {
0: self.PHY_damage_resistance,
1: self.FIRE_damage_resistance,
2: self.ICE_damage_resistance,
3: self.ELECTRIC_damage_resistance,
4: self.ETHER_damage_resistance,
5: self.ICE_damage_resistance,
6: self.ETHER_damage_resistance,
}
self.anomaly_resistance_dict: dict[int, float] = {
0: self.PHY_anomaly_resistance,
1: self.FIRE_anomaly_resistance,
2: self.ICE_anomaly_resistance,
3: self.ELECTRIC_anomaly_resistance,
4: self.ETHER_anomaly_resistance,
5: self.ICE_anomaly_resistance,
6: self.ETHER_anomaly_resistance,
}
self.stun_resistance_dict: dict[int, float] = {
0: self.PHY_stun_resistance,
1: self.FIRE_stun_resistance,
2: self.ICE_stun_resistance,
3: self.ELECTRIC_stun_resistance,
4: self.ETHER_stun_resistance,
5: self.ICE_stun_resistance,
6: self.ETHER_stun_resistance,
}
# 初始化敌人设置
self.settings = EnemySettings()
self.__apply_settings(self.settings)
# 下面的两个dict本来写在外面的，但是别的程序也要用这两个dict，所以索性写进来了。我是天才。
self.trans_element_number_to_str = {
0: "PHY",
1: "FIRE",
2: "ICE",
3: "ELECTRIC",
4: "ETHER",
5: "FIREICE",
6: "AURICINK",
}
self.trans_anomaly_effect_to_str = {
0: "assault",
1: "burn",
2: "frostbite",
3: "shock",
4: "corruption",
5: "frost_frostbite",
6: "auricink_corruption",
}
# enemy实例化的时候，6种异常积蓄条也随着一起实例化
self.frost_anomaly_bar = FrostAnomaly(sim_instance=self.sim_instance)
self.ice_anomaly_bar = IceAnomaly(sim_instance=self.sim_instance)
self.fire_anomaly_bar = FireAnomaly(sim_instance=self.sim_instance)
self.physical_anomaly_bar = PhysicalAnomaly(sim_instance=self.sim_instance)
self.ether_anomaly_bar = EtherAnomaly(sim_instance=self.sim_instance)
self.electric_anomaly_bar = ElectricAnomaly(sim_instance=self.sim_instance)
self.auricink_anomaly_bar = AuricInkAnomaly(sim_instance=self.sim_instance)
"""
由于在AnomalyBar的init中有一个update_anomaly函数，
该函数可以根据传入new_snap_shot: tuple 的第0位的属性标号，
找到对应的anomaly_bar的实例，并且执行它的update_snap_shot 函数。
以更新对应的积蓄快照。
本来，这个dict应该建立在update_anomaly函数中，但是考虑到该函数会反复调用，频繁地创建这个dict会导致性能的浪费。
所以将其挪到Enemy的init中，这样，这个dict只在Enemy实例化时被创建一次，
然后update_anomaly函数将通过enemy.anomaly_bars_dict来调出对应的anomaly_bars实例。
"""
self.anomaly_bars_dict: dict[int, AnomalyBar] = {
0: self.physical_anomaly_bar,
1: self.fire_anomaly_bar,
2: self.ice_anomaly_bar,
3: self.electric_anomaly_bar,
4: self.ether_anomaly_bar,
5: self.frost_anomaly_bar,
6: self.auricink_anomaly_bar,
}
# 在初始化阶段更新属性异常条最大值。
for element_type in self.anomaly_bars_dict:
anomaly_bar = self.anomaly_bars_dict[element_type]
max_value = getattr(
self, f"max_anomaly_{self.trans_element_number_to_str[element_type]}"
)
anomaly_bar.max_anomaly = max_value
if self.data_dict["进攻策略"] is None or self.data_dict["进攻策略"] is np.nan:
attack_method_code = 0
else:
attack_method_code = int(self.data_dict["进攻策略"])
self.attack_method = EnemyAttackMethod(ID=attack_method_code, enemy_instance=self)
self.restore_stun()
self.unique_machanic_manager = unique_mechanic_factory(self) # 特殊机制管理器
self.special_state_manager = SpecialStateManager(enemy_instance=self)
report_to_log(f"[ENEMY]: 怪物对象 {self.name} 已创建，怪物ID {self.index_ID}", level=4)
def __restore_stun_recovery_time(self):
self.stun_recovery_time = float(self.data_dict["失衡恢复时间"]) * 60
def restore_stun(self):
"""还原 Enemy 本身的失衡恢复时间，与QTE计数"""
self.dynamic.stun = False
self.dynamic.stun_bar = 0
self.dynamic.stun_tick = 0
self.dynamic.stun_tick_feed_back_from_QTE = 0
self.__restore_stun_recovery_time()
if self.qte_manager is None:
self.qte_manager = QTEManager(self)
self.qte_manager.qte_data.restore()
def increase_stun_recovery_time(self, increase_tick: int):
"""更新失衡延长的时间，负责接收 Calculator 的 buff"""
if self.__last_stun_increase_tick is None:
self.__last_stun_increase_tick = increase_tick
self.stun_recovery_time += increase_tick
else:
if increase_tick >= self.__last_stun_increase_tick:
self.__last_stun_increase_tick = increase_tick
self.__restore_stun_recovery_time()
self.stun_recovery_time += increase_tick
def get_active_anomaly_bar(self) -> type[AnomalyBar]:
"""用于外部获取当前正在激活的属性异常条对象"""
output_list = []
for element_type, anomaly_bar in self.anomaly_bars_dict.items():
if anomaly_bar.active:
output_list.append(self.dynamic.active_anomaly_bar_dict[element_type])
if len(output_list) == 0 or len(output_list) > 1:
raise ValueError(f"状态错误！找到了{len(output_list)}种正在激活的属性异常条！")
return output_list[0]
@staticmethod
def __lookup_enemy(
enemy_df: pd.DataFrame,
enemy_name: str | None = None,
enemy_index_ID: int | None = None,
enemy_sub_ID: int | None = None,
) -> tuple[str, int, int, dict]:
"""
根据敌人名称或ID查找敌人信息，并返回敌人名称、IndexID和SubID。
若输入多个参数，此函数会检测这些参数是否一一对应
!!!注意!!!因为可能存在重名敌人的问题，使用中文名称查找怪物时，只会返回ID更靠前的
因此，在已经输入了ID的情况下，函数不会优先根据中文名查找
参数:
- enemy_df: pd.DataFrame, 敌人数据 DataFrame，包含敌人信息。
- enemy_name: str, 可选，敌人名称。
- enemy_index_ID: int, 可选，敌人IndexID。
- enemy_sub_ID: int, 可选，敌人SubID。
返回：
- 有传入参数时，返回对应怪物的数据
- 无传入参数时，返回尼尼微的数据
"""
# fmt: off
try:
if enemy_index_ID is not None:
row = enemy_df[enemy_df["IndexID"] == enemy_index_ID].to_dict("records")
elif enemy_sub_ID is not None:
row = enemy_df[enemy_df["SubID"] == enemy_sub_ID].to_dict("records")
elif enemy_name is not None:
row = enemy_df[enemy_df["CN_enemy_ID"] == enemy_name].to_dict("records")
else:
row = enemy_df[enemy_df["IndexID"] == 11531].to_dict("records") # 默认打尼尼微（因为全部0抗）
if not row:
raise ValueError(f"找不到对应的敌人，请检查输入参数：name={enemy_name}, index_id={enemy_index_ID}, sub_id={enemy_sub_ID}")
except IndexError:
raise ValueError("找不到对应的敌人")
# fmt: on
row_0: dict = row[0]
name: str = row_0["CN_enemy_ID"]
index_ID: int = int(row_0["IndexID"])
sub_ID: int = int(row_0["SubID"])
# 检查输入的变量与查到的变量是否一致
if enemy_name is not None:
if name != enemy_name:
raise ValueError("传入的name与ID不匹配")
if enemy_index_ID is not None:
if index_ID != enemy_index_ID:
raise ValueError("传入的name与ID不匹配")
if enemy_sub_ID is not None:
if sub_ID != enemy_sub_ID:
raise ValueError("传入的name与ID不匹配")
return name, index_ID, sub_ID, row_0
@staticmethod
def __lookup_enemy_adjustment(
adjust_df: pd.DataFrame, adjust_ID: int | None = None
) -> dict[Literal["生命值", "攻击力", "失衡值上限", "防御力", "异常积蓄值上限"], float]: # type: ignore
"""根据调整ID查找敌人调整数据，并返回调整数据字典。"""
if adjust_ID is not None:
try:
row = adjust_df[adjust_df["ID"] == adjust_ID].to_dict("records")
except IndexError:
raise ValueError(f"找不到属性调整ID：{adjust_ID}")
row_0: dict[
Literal["生命值", "攻击力", "失衡值上限", "防御力", "异常积蓄值上限"], float
] = dict(row[0]) # type: ignore
return row_0
else:
return {
"生命值": 0,
"攻击力": 0,
"失衡值上限": 0,
"防御力": 0,
"异常积蓄值上限": 0,
}
@staticmethod
def __init_enemy_anomaly(
able_to_get_anomaly: bool, QTE_triggerable_times: int, adjust: float
) -> tuple[int | float, int | float]:
"""
根据敌人的异常能力和QTE触发次数(怪物等阶)初始化敌人的异常值。
参数:
able_to_get_anomaly (bool): 敌人是否能获得异常值。
QTE_triggerable_times (int): QTE可触发的次数。
返回:
tuple: 包含两个值，分别为基础异常值和物理异常值。
"""
if able_to_get_anomaly:
# 定义基础异常值
base_anomaly = 150 * (1 + adjust)
# 定义物理异常值的乘数
physical_anomaly_mul = 1.2
# 计算物理异常值
base_anomaly_physical = base_anomaly * physical_anomaly_mul
# 根据QTE触发次数返回相应的异常值
if QTE_triggerable_times == 1:
return base_anomaly * 4, base_anomaly_physical * 4
elif QTE_triggerable_times == 2:
return base_anomaly * 15, base_anomaly_physical * 15
elif QTE_triggerable_times == 3:
return base_anomaly * 20, base_anomaly_physical * 20
else:
# 如果QTE触发次数不符合已定义的条件，返回默认异常值
return 3000, 3600 # 默认异常值
else:
return 0, 0
def __apply_settings(self, settings: EnemySettings):
if settings.enemy_info_overwrite:
if settings.forced_no_stun:
self.able_to_be_stunned = False
if settings.forced_no_anomaly:
self.able_to_get_anomaly = False
self.stun_DMG_take_ratio = settings.forced_stun_DMG_take_ratio
else:
pass
def update_max_anomaly(self, element: str | int = "ALL", *, times: int = 1) -> None:
"""更新怪物异常值，触发一次异常后调用。"""
# 参数类型检查
if not isinstance(element, (str, int)):
raise TypeError(f"element参数类型错误，必须是整数或字符串，实际类型为{type(element)}")
if not isinstance(times, int):
raise TypeError(f"times参数必须是整数，实际类型为{type(times)}")
if times <= 0:
raise ValueError(f"times参数必须大于0，实际值为{times}")
# 属性类型映射表
element_mapping: dict[str, tuple] = {
"PHY": ("物理", 0),
"FIRE": ("火", 1),
"ICE": ("冰", 2),
"ELECTRIC": ("电", 3),
"ETHER": ("以太", 4),
"FROST": ("烈霜", "FIREICE", 5),
"AURICINK": ("玄墨", 6),
"ALL": ("全部", "所有"),
}
# 检查并标准化元素
if isinstance(element, str):
element = element.upper()
for key, values in element_mapping.items():
if element in (key, *values):
element = key
break
else:
raise ValueError(f"输入了不支持的元素种类：{element}")
elif isinstance(element, int):
for key, values in element_mapping.items():
if element in values:
element = key
break
else:
raise ValueError(f"输入了不支持的元素种类：{element}")
else:
raise ValueError(f"无法识别的元素种类：{element}")
# 更新比例
update_ratio = 1.02 # 每次异常增加 2% 对应属性异常值
# 确保 times 在合理范围内
if times > 1e6: # 防止极端值导致性能问题
raise ValueError(f"times参数过大，可能导致性能问题，实际值为{times}")
# 计算最终更新比例
multiplier = update_ratio**times
# 批量更新异常值
if element == "ALL":
self.max_anomaly_ICE *= multiplier
self.max_anomaly_FIRE *= multiplier
self.max_anomaly_ETHER *= multiplier
self.max_anomaly_ELECTRIC *= multiplier
self.max_anomaly_PHY *= multiplier
self.max_anomaly_FIREICE *= multiplier
self.max_anomaly_AURICINK *= multiplier
else:
# 单个元素更新
if element == "ICE":
self.max_anomaly_ICE *= multiplier
elif element == "FIRE":
self.max_anomaly_FIRE *= multiplier
elif element == "ETHER":
self.max_anomaly_ETHER *= multiplier
elif element == "ELECTRIC":
self.max_anomaly_ELECTRIC *= multiplier
elif element == "PHY":
self.max_anomaly_PHY *= multiplier
elif element == "FROST":
self.max_anomaly_FIREICE *= multiplier
elif element == "AURICINK":
self.max_anomaly_AURICINK *= multiplier
def update_stun(self, stun: np.float64) -> None:
self.dynamic.stun_bar += stun
def hit_received(self, single_hit: SingleHit, tick: int) -> None:
"""实现怪物的QTE次数计算、扣血计算等受击时的对象结算，与伤害计算器对接"""
# 更新失衡，为减少函数调用
self.dynamic.stun_bar += single_hit.stun
self.stun_judge(tick, single_hit=single_hit)
# 怪物的扣血逻辑。
self.__HP_update(single_hit.dmg_expect)
# 更新异常值
self.__anomaly_prod(single_hit.snapshot, single_hit=single_hit)
if self.unique_machanic_manager is not None:
self.unique_machanic_manager.update_myself(single_hit, tick)
# 更新连携管理器
assert (
self.qte_manager is not None
and self.sim_instance.preload.preload_data.atk_manager is not None
)
self.qte_manager.receive_hit(single_hit)
self.sim_instance.preload.preload_data.atk_manager.receive_single_hit(
single_hit=single_hit, tick=tick
)
# 在接收hit的时，向所有特殊状态进行广播，执行更新自检！
self.special_state_manager.broadcast_and_update(
signal=SSUS.RECEIVE_HIT, single_hit=single_hit
)
# 遥远的需求：
# TODO：实时DPS的计算，以及预估战斗结束时间，用于进一步优化APL。（例：若目标预计死亡时间<5秒，则不补buff）
def get_total_hp_percentage(self) -> float:
"""获取当前生命值百分比的方法（总量百分比）"""
return 1 - self.dynamic.lost_hp / self.max_HP
def get_current_hp_percentage(self) -> float:
"""获取当前生命值百分比的方法（小血条百分比）"""
return 1 - self.dynamic.lost_hp % self.base_max_HP / self.base_max_HP
def get_stun_percentage(self) -> float:
"""获取当前失衡值百分比的方法"""
return self.dynamic.stun_bar / self.max_stun
def get_stun_rest_tick(self) -> float:
"""获取当前剩余失衡时间的方法"""
# TODO：未完全实现！连携技返还失衡时间部分尚未完成。
if not self.dynamic.stun:
return 0
return (
self.stun_recovery_time
- self.dynamic.stun_tick
+ self.dynamic.stun_tick_feed_back_from_QTE
)
def stun_judge(self, _tick: int, **kwargs) -> bool:
"""判断敌人是否处于 失衡 状态，并更新 失衡 状态"""
single_hit = kwargs.get("single_hit", None)
if not self.able_to_be_stunned:
self.dynamic.stun_update_tick = _tick
return False
if self.dynamic.stun:
# 如果已经是失衡状态，则判断是否恢复
if (
self.stun_recovery_time + self.dynamic.stun_tick_feed_back_from_QTE
<= self.dynamic.stun_tick
):
self.dynamic.stun_update_tick = _tick
self.restore_stun()
else:
if _tick - self.dynamic.stun_update_tick > 1:
raise ValueError("状态更新间隔大于1！存在多个tick都未更新stun的情况！")
self.dynamic.stun_bar = 0 # 避免 log 差错
self.dynamic.stun_update_tick = _tick
# 若怪物当前处于冻结状态，则不增加stun_tick
if not self.dynamic.frozen:
self.dynamic.stun_tick += 1
# else:
# print("检测到怪物当前处于冻结状态，所以不会增加stun_tick！！")
elif self.dynamic.stun_bar >= self.max_stun:
# 若是检测到失衡状态的上升沿，则应该开启彩色失衡状态。
assert self.qte_manager is not None
self.qte_manager.qte_data.reset()
print("怪物陷入失衡了！")
self.dynamic.stun = True
self.dynamic.stun_bar = 0 # 避免 log 差错
self.dynamic.stun_update_tick = _tick
if single_hit:
self.sim_instance.decibel_manager.update(single_hit=single_hit, key="stun")
self.sim_instance.listener_manager.broadcast_event(
event=single_hit, signal=LBS.STUN
)
assert self.sim_instance.preload.preload_data.atk_manager is not None
if self.sim_instance.preload.preload_data.atk_manager.attacking:
self.sim_instance.preload.preload_data.atk_manager.interrupted(
tick=_tick, reason="被打进失衡"
)
return self.dynamic.stun
def __HP_update(self, dmg_expect: np.float64) -> None:
"""用于更新敌人已损生命值"""
self.dynamic.lost_hp += dmg_expect
if (minus := self.max_HP - self.dynamic.lost_hp) <= 0:
self.dynamic.lost_hp = -1 * minus
report_to_log(f"怪物{self.name}死亡！")
def __anomaly_prod(
self, snapshot: tuple[int, np.float64, np.ndarray], single_hit: SingleHit
) -> None:
"""用于更新异常条的角色面板快照"""
if snapshot[1] >= 1e-6: # 确保非零异常值才更新
element_type_code = snapshot[0]
updated_bar = self.anomaly_bars_dict[element_type_code]
updated_bar.update_snap_shot(snapshot, single_hit=single_hit)
def reset_myself(self):
self.dynamic.reset_myself()
self.reset_anomaly_bars()
assert self.qte_manager is not None
self.qte_manager.reset_myself()
self.attack_method.reset_myself()
if self.unique_machanic_manager is not None:
self.unique_machanic_manager.reset_myself()
def reset_anomaly_bars(self):
"""重置异常条！"""
max_element_anomaly, self.max_anomaly_PHY = self.__init_enemy_anomaly(
self.able_to_get_anomaly,
self.QTE_triggerable_times,
self.enemy_adjust["异常积蓄值上限"],
)
self.max_anomaly_ICE = self.max_anomaly_FIRE = self.max_anomaly_ETHER = (
self.max_anomaly_ELECTRIC
) = self.max_anomaly_FIREICE = max_element_anomaly
for element_type, anomaly_bar in self.anomaly_bars_dict.items():
anomaly_bar.reset_myself()
max_value = getattr(
self, f"max_anomaly_{self.trans_element_number_to_str[element_type]}"
)
anomaly_bar.max_anomaly = max_value
def find_dot(self, dot_tag: str) -> object | None:
"""通过dot名，查找enemy身上是否存在此dot"""
for dots in self.dynamic.dynamic_dot_list:
if dots.ft.index == dot_tag and dots.dy.active:
return dots
else:
continue
else:
return None
class EnemyDynamic:
def __init__(self, enemy_instance):
self.enemy: Enemy = enemy_instance
self.stun = False # 失衡状态
self.stun_update_tick = 0 # 上次更新失衡状态的时间
self.frozen = False # 冻结状态
self.frostbite = False # 霜寒状态
self.frost_frostbite = False # 烈霜霜寒状态
self._assault = False # 畏缩状态
self.shock = False # 感电状态
self.burn = False # 灼烧状态
self.corruption = False # 侵蚀状态
self.auricink_corruption = False # 玄墨侵蚀状态
self.dynamic_debuff_list = [] # 用来装debuff的list
# from zsim.sim_progress.data_struct.monitor_list_class import MonitoredList
# self.dynamic_dot_list = MonitoredList() # 用来装dot的list
self.dynamic_dot_list = [] # 用来装dot的list
self.active_anomaly_bar_dict: dict[int, type[AnomalyBar] | None] = {
number: AnomalyBar for number in range(6)
} # 用来装激活属性异常的字典。
self.stun_bar = 0 # 累计失衡条
self.lost_hp = 0 # 已损生命值
self.stun_tick = 0 # 失衡已进行时间
self.stun_tick_feed_back_from_QTE = 0 # 从QTE中返还的失衡时间
self.frozen_tick = 0
self.frostbite_tick = 0
self.assault_tick = 0
self.shock_tick = 0
self.burn_tick = 0
self.corruption_tick = 0
@property
def assault(self) -> bool:
return self._assault
@assault.setter
def assault(self, value: bool):
# 由于监听器可能需要更新，所以这里要先赋值，再广播；
self._assault = value
if value:
# 检查更新值并且广播给各监听器（目前只为爱丽丝核心被动Dot触发器服务）
sim_instance = self.enemy.sim_instance
sim_instance.listener_manager.broadcast_event(
signal=LBS.ASSAULT_STATE_ON, event=self.enemy.anomaly_bars_dict[0]
)
def __str__(self):
return f"失衡: {self.stun}, 失衡条: {self.stun_bar:.2f}, 冻结: {self.frozen}, 霜寒: {self.frostbite}, 畏缩: {self.assault}, 感电: {self.shock}, 灼烧: {self.burn}, 侵蚀：{self.corruption}, 烈霜霜寒：{self.frost_frostbite}"
def get_status(self) -> dict:
return {
"失衡状态": self.stun,
"失衡条": self.stun_bar,
"已损生命值": self.lost_hp,
"冻结": self.frozen,
"霜寒": self.frostbite,
"畏缩": self.assault,
"感电": self.shock,
"灼烧": self.burn,
"侵蚀": self.corruption,
"烈霜霜寒": self.frost_frostbite,
"玄墨侵蚀": self.auricink_corruption,
}
def reset_myself(self):
self.stun: bool = False
self.stun_update_tick: int = 0
self.frozen: bool = False
self.frostbite: bool = False
self.frost_frostbite: bool = False
self.assault: bool = False
self.shock: bool = False
self.burn: bool = False
self.corruption: bool = False
self.dynamic_debuff_list: list = []
self.dynamic_dot_list: list = []
self.active_anomaly_bar_dict = {number: None for number in range(6)}
self.stun_bar: float = 0
self.lost_hp: float = 0
self.stun_tick: int = 0
self.frozen_tick: int = 0
self.frostbite_tick: int = 0
self.assault_tick: int = 0
self.shock_tick: int = 0
self.burn_tick: int = 0
self.corruption_tick: int = 0
self.stun_tick_feed_back_from_QTE: int = 0
def is_under_anomaly(self) -> bool:
"""若敌人正处于任意一种异常状态下，都会返回True"""
return any(
[
self.frostbite,
self.frost_frostbite,
self.assault,
self.burn,
self.corruption,
self.shock,
self.auricink_corruption,
]
)
def get_active_anomaly(self) -> list[type[AnomalyBar] | None]:
if self.is_under_anomaly():
return [
_anomaly_bar
for _anomaly_bar in self.active_anomaly_bar_dict.values()
if _anomaly_bar is not None and _anomaly_bar.active
]
else:
return []
def __str__(self):
return f"{self.name}: {self.dynamic.__str__()}"
def __deepcopy__(self, memo):
return self
if __name__ == "__main__":
test = Enemy(index_id=11432, sub_ID=900011432)
print(test.ice_anomaly_bar.max_anomaly)
================================================
FILE: zsim/sim_progress/Load/LoadDamageEvent.py
================================================
from zsim.sim_progress.Preload import SkillNode
# import Enemy
from zsim.sim_progress.Report import report_to_log
from .. import Dot
from .loading_mission import LoadingMission
def SpawnDamageEvent(mission: LoadingMission | Dot.Dot, event_list: list):
"""
负责往event_list中添加伤害生成事件，添加的内容是实例：
要么是SkillNode的实例，要么是Dot的实例。
"""
if isinstance(mission, LoadingMission):
if mission.hitted_count > mission.mission_node.hit_times:
raise ValueError(
f"{mission.mission_tag}目前是第{mission.hitted_count}，最多{mission.mission_node.hit_times}"
)
mission.hitted_count += 1
event_list.append(mission)
elif isinstance(mission, Dot.Dot):
if (
mission.dy.effect_times > mission.ft.max_effect_times
and not mission.ft.complex_exit_logic
):
raise ValueError("该Dot任务已经完成，应当被删除！")
if mission.anomaly_data is not None:
event_list.append(mission.anomaly_data)
else:
event_list.append(mission.skill_node_data)
def ProcessTimeUpdateDots(timetick: int, dot_list: list, event_list: list):
"""
处理effect_rules == 1的Dot对象，始终检查是否应触发。
"""
for dot in dot_list:
if not isinstance(dot, Dot.Dot):
raise TypeError(f"{dot}不是Dot类！")
# 只处理 effect_rules == 1 的 Dot
if dot.ft.effect_rules == 1:
dot.ready_judge(timetick)
if dot.dy.ready:
dot.dy.last_effect_ticks = timetick
dot.dy.ready = False
dot.dy.effect_times += 1
SpawnDamageEvent(dot, event_list)
def ProcessHitUpdateDots(timetick: int, dot_list: list, event_list: list):
"""
处理effect_rules == 2的Dot对象，只在Mission触发或是Schedule进行检查。
"""
for dot in dot_list:
if not isinstance(dot, Dot.Dot):
raise TypeError(f"{dot}不是Dot类！")
# 只处理 effect_rules == 2 的 Dot
if dot.ft.effect_rules == 2:
dot.ready_judge(timetick)
if dot.dy.ready:
SpawnDamageEvent(dot, event_list)
dot.dy.ready = False
dot.dy.last_effect_ticks = timetick
dot.dy.effect_times += 1
def ProcessFreezLikeDots(timetick: int, enemy, event_list: list, event):
"""
所有碎冰类逻辑的dot都用此函数结算。
"""
dot_list = enemy.dynamic.dynamic_dot_list
skill_tag: str
is_heavy_attack: bool
if isinstance(event, LoadingMission):
skill_tag = event.mission_tag
if not event.is_heavy_hit(timetick):
is_heavy_attack = False
else:
is_heavy_attack = True
elif isinstance(event, SkillNode):
skill_tag = event.skill_tag
if not event.is_heavy_hit(timetick):
is_heavy_attack = False
else:
is_heavy_attack = True
else:
raise TypeError(
f"ProcessFreezLikeDots函数接收到的{event}不是LoadingMission或是SkillNode类！"
)
if not is_heavy_attack:
if "1291_CorePassive" not in skill_tag:
return False
for dot in dot_list[:]:
if not isinstance(dot, Dot.Dot):
raise TypeError(f"{dot}不是Dot类！")
if dot.ft.effect_rules != 4:
continue
dot.ready_judge(timetick)
if dot.dy.ready:
print(f"{skill_tag}结算了碎冰！")
SpawnDamageEvent(dot, event_list)
dot.dy.ready = False
dot.dy.last_effect_ticks = timetick
dot.dy.effect_times += 1
dot_list.remove(dot)
enemy.dynamic.frozen = False
return True
def DamageEventJudge(
timetick: int,
load_mission_dict: dict,
enemy,
event_list: list,
char_obj_list: list,
**kwargs,
):
"""
DamageEvent的Judge函数：轮询load_mission_dict以及enemy.dynamic_dot_list，判断是否应生成Hit事件。
并且当Hit时间生成时，将对应的实例添加到event_list中。
当前可能产生Hit的mission类型共有两种，第一种是动作类，第二种是Dot类。
1-动作类：
首先应该查询mission.mission_dict，并且查询所有的键值，检查是否有键值需要在本tick处理。
如果有，则应该将mission.mission_node传递给Schedule Event List。
2-Dot类：
首先应明确是固定随时间变化的Dot，还是命中后才产生伤害的Dot。这一条件以Dot.effect_rules来区分。
如果effect_rules = 1，则表明是仅根据时间和内置CD来产生伤害的，则应该每个Tick都随着本函数执行一次判断；
如果effect_rules = 2，则表明是根据命中来产生伤害的，则应该和动作类mission一起判断。
同时，本函数还会在子任务是end的时候检查enemy的积蓄值。如果积蓄值满，则会触发异常（update_anomaly函数）
"""
# 处理 Load.Mission 任务
# dynamic_buff_dict = kwargs.get("dynamic_buff_dict", None)
process_overtime_mission(timetick, load_mission_dict)
for mission in load_mission_dict.values():
if not isinstance(mission, LoadingMission):
raise TypeError(f"{mission}不是LoadingMission类！")
if mission.is_hit_now(timetick):
SpawnDamageEvent(mission, event_list)
# 当Mission触发时，检查 effect_rules == 2 的 Dot
# ProcessHitUpdateDots(timetick, enemy.dynamic.dynamic_dot_list, event_list)
# 始终检查 effect_rules == 1 的 Dot
ProcessTimeUpdateDots(timetick, enemy.dynamic.dynamic_dot_list, event_list)
# TODO：预留接口：处理effect_rules == 3 的buff（但是涉及快照）
def process_overtime_mission(tick: int, Load_mission_dict: dict):
"""去除过期任务！"""
to_remove = []
for key, mission in Load_mission_dict.items():
if not isinstance(mission, LoadingMission):
continue
mission.check_myself(tick)
if not mission.mission_active_state:
if key not in to_remove:
to_remove.append(key)
for key in to_remove:
report_to_log(
f"[Skill LOAD]:{tick}:{Load_mission_dict[key].mission_tag}已经结束,已从Load中移除",
level=2,
)
Load_mission_dict.pop(key)
# for mission_key, mission in Load_mission_dict.items():
# if mission_key == '1331_CoAttack_A':
# print(mission_key, mission.mission_node.preload_tick, mission.mission_node.end_tick)
================================================
FILE: zsim/sim_progress/Load/SkillEventSplit.py
================================================
from zsim.sim_progress import Load, Preload
from zsim.sim_progress.data_struct import ActionStack
def SkillEventSplit(
preloaded_action_list: list,
Load_mission_dict: dict,
name_dict: dict,
timenow,
action_stack: ActionStack,
):
# 新增新的loading mission
for i in range(len(preloaded_action_list)):
skill = preloaded_action_list.pop()
if not isinstance(skill, Preload.SkillNode):
raise ValueError(f"本次拆分的{type(skill)}不是SkillNode类！")
# print(f"{timenow}tick：技能{skill.skill_tag}正式生效")
this_mission = Load.LoadingMission(skill)
this_mission.mission_start(timenow)
action_stack.push(this_mission)
if skill.skill_tag in name_dict:
name_dict[skill.skill_tag] += 1
else:
name_dict[skill.skill_tag] = 1
key = skill.skill_tag + f"[{name_dict[skill.skill_tag]}]"
Load_mission_dict[key] = this_mission
return Load_mission_dict
if __name__ == "__main__": # 测试
import tqdm
timelimit = 3600
load_mission_dict = {}
p = Preload.Preload()
name_dict = {}
for tick in tqdm.trange(timelimit):
p.do_preload(tick)
preload_action_list = p.preload_data.preloaded_action
if not preload_action_list:
continue
SkillEventSplit(preload_action_list, load_mission_dict, name_dict)
for item in load_mission_dict:
print(f"{item}, {load_mission_dict[item].mission_character_number}")
# TODO: 将SkillEventSplit中，对于load_mission_dict的维护部分单独拆分，并且每个ticks查询，如果当前有hit子任务，则直接向schedule_event_list添加对应的SkillNode
================================================
FILE: zsim/sim_progress/Load/__init__.py
================================================
from .LoadDamageEvent import DamageEventJudge
from .loading_mission import LoadingMission
from .SkillEventSplit import SkillEventSplit
__all__ = [
"DamageEventJudge",
"LoadingMission",
"SkillEventSplit",
]
================================================
FILE: zsim/sim_progress/Load/loading_mission.py
================================================
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Report import report_to_log
class LoadingMission:
def __init__(self, mission: SkillNode):
self.mission_active_state = False
self.mission_node = mission
self.mission_dict = {}
self.mission_start_tick = mission.preload_tick
self.hitted_count = 0 # 已经结算的hit数量
self.mission_tag = mission.skill_tag
self.mission_end_tick = mission.end_tick
self.mission_character = mission.char_name
self.preload_tick = mission.preload_tick
self.mission_node.loading_mission = self # type: ignore
def mission_start(self, timenow: int, **kwargs) -> None:
report = kwargs.get("report", True)
self.mission_active_state = True
timecost = self.mission_node.skill.ticks
if timecost:
time_step = (timecost - 1) / (self.mission_node.hit_times + 1)
self.mission_dict[float(self.mission_node.preload_tick)] = "start"
# if self.mission_node.hit_times == 1:
# self.mission_dict[float(self.mission_node.preload_tick+timecost - 1)/2] = "hit"
# else:
if self.mission_node.skill.tick_list:
for hit_tick in self.mission_node.skill.tick_list:
tick_key = self.mission_node.preload_tick + hit_tick
self.mission_dict[tick_key] = "hit"
else:
for i in range(self.mission_node.hit_times):
tick_key = self.mission_node.preload_tick + time_step * (i + 1)
# 由于timetick在循环中的自增量是整数，所以为了保证能和键值准确匹配，
# 这里的键值也要向上取整，注意，这里产生的是一个int，所以要转化为float
self.mission_dict[tick_key] = "hit"
self.mission_dict[float(self.mission_node.preload_tick + timecost)] = "end"
report_to_log(
f"[Skill LOAD]:{timenow}:{self.mission_tag}开始并拆分子任务。", level=4
) if report else None
else:
self.mission_dict[timenow] = "hit"
def mission_end(self) -> None:
self.mission_active_state = False
self.hitted_count = 0
self.mission_dict = {}
def check_myself(self, timenow: int) -> None:
if self.mission_end_tick < timenow:
self.mission_end()
return
def get_first_hit(self) -> int | None:
"""返回首次命中的时间"""
tick_list = list(self.mission_dict.keys())
while tick_list:
tick = min(tick_list)
if self.mission_dict[tick] == "hit":
return tick
else:
tick_list.remove(tick)
def is_hit_now(self, tick_now: int) -> bool:
"""检测当前tick是否有hit事件。"""
for _tick in self.mission_dict.keys():
if tick_now - 1 < _tick <= tick_now:
if self.mission_dict[_tick] == "hit":
return True
else:
return False
def get_last_hit(self) -> int | None:
"""返回最后一次命中的时间"""
tick_list = list(self.mission_dict.keys())
while tick_list:
tick = max(tick_list)
if self.mission_dict[tick] == "hit":
return tick
else:
tick_list.remove(tick)
def is_first_hit(self, tick: int) -> bool:
first_hit = self.get_first_hit()
if first_hit is None:
return False
return tick - 1 < first_hit <= tick
def is_last_hit(self, tick: int) -> bool:
last_hit = self.get_last_hit()
if last_hit is None:
return False
return tick - 1 < last_hit <= tick
def is_heavy_hit(self, tick: int) -> bool:
if not self.is_last_hit(tick):
return False
else:
if self.mission_node.skill.heavy_attack:
return True
else:
return False
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLClass.py
================================================
import json
from typing import TYPE_CHECKING
from zsim.define import APL_NA_ORDER_PATH, CHAR_PARRY_STRATEGY_MAP
from zsim.sim_progress.data_struct.NormalAttackManager import (
BaseNAManager,
na_manager_factory,
)
from zsim.sim_progress.Preload.APLModule.ActionReplaceManager import (
ActionReplaceManager,
)
from ..apl_unit.ActionAPLUnit import ActionAPLUnit
from .APLOperator import APLOperator
if TYPE_CHECKING:
from zsim.sim_progress.Character.character import Character
from zsim.sim_progress.Preload import PreloadData
from zsim.simulator.simulator_class import Simulator
class APLClass:
"""
APL代码的执行部分。它会调用apl_condition并且轮询所有的APL代码，
找出第一个符合条件的动作并且执行。
"""
def __init__(
self,
all_apl_unit_list: list,
preload_data: "PreloadData | None" = None,
sim_instance: "Simulator | None" = None,
):
self.game_state: dict | None = None
self.sim_instance: "Simulator | None" = sim_instance
self.preload_data = preload_data
self.actions_list = all_apl_unit_list
self.na_manager_dict: dict[int, BaseNAManager] = {}
try:
json_path = APL_NA_ORDER_PATH
with open(json_path, "r", encoding="utf-8") as file:
self.NA_action_dict = json.load(file)
except (FileNotFoundError, json.JSONDecodeError) as e:
print(f"初始化时发生错误: {e}")
self.NA_action_dict = {}
self.apl_operator: APLOperator | None = None
self.repeat_action: tuple[str, int] = ("", 0)
self.action_replace_manager = None
self.char_obj_dict: dict[int, "Character"] = {}
def execute(self, tick, mode: int) -> tuple[str, int, ActionAPLUnit]:
if self.game_state is None:
self.get_game_state()
if self.apl_operator is None:
assert self.preload_data is not None, "Preload_data is not initialized"
assert self.sim_instance is not None, "Simulator instance is not initialized"
assert self.game_state is not None, "Game state is not initialized"
self.apl_operator = APLOperator(
self.actions_list,
self.game_state,
simulator_instance=self.sim_instance,
preload_data=self.preload_data,
)
assert self.preload_data is not None
assert self.apl_operator is not None
assert self.preload_data.atk_manager is not None
cid, skill_tag, apl_priority, apl_unit = (
self.apl_operator.spawn_next_action_in_common_mode(tick)
if not self.preload_data.atk_manager.attacking
else self.apl_operator.spawn_next_action_in_atk_response_mode(tick)
)
final_result = self.perform_action(cid, skill_tag, tick)
# FIXME: 这里的优先级修改可能存在问题，需要重新考虑一下。
# if final_result != skill_tag:
# apl_priority = 0
return final_result, apl_priority, apl_unit
def get_game_state(self) -> dict | None:
if self.game_state is None:
try:
# 延迟从 sys.modules 获取字典A，假设 main 模块中已定义字典 A
# main_module = sys.modules["simulator.main_loop"]
# if main_module is None:
# raise ImportError("Main module not found.")
# self.game_state = main_module.game_state # 获取 main 中的 A
if self.preload_data and self.preload_data.sim_instance:
self.game_state = self.preload_data.sim_instance.game_state
except Exception as e:
print(f"Error loading dictionary A: {e}")
return self.game_state
def perform_action(self, CID: int, action: str, tick: int) -> str:
"""APL逻辑判定通过，执行动作！"""
if self.game_state is None:
self.game_state = self.get_game_state()
if self.preload_data is None:
assert self.game_state is not None, "Game state is not initialized"
preload_from_game_state = self.game_state.get("preload")
assert preload_from_game_state is not None, "Preload object not in game_state"
self.preload_data = preload_from_game_state.preload_data
output = self.action_processor(CID, action, tick)
return output
def action_processor(self, CID, action, tick) -> str:
"""用于生成动作，以及模拟游戏内的部分动作替换逻辑"""
if self.action_replace_manager is None:
self.action_replace_manager = ActionReplaceManager(self.preload_data)
result_tupe = self.action_replace_manager.action_replace_factory(CID, action, tick)
if result_tupe[0]:
output = result_tupe[1]
else:
output = self.spawn_action_directly(CID, action)
return output
def spawn_action_directly(self, CID: int, action: str):
"""在没有被快速支援、或是其他技能拦截的情况下，直接生成动作"""
assert self.preload_data is not None
if CID not in self.char_obj_dict:
assert self.sim_instance.char_data is not None, "Preload_data is not initialized"
for _char_obj in self.sim_instance.char_data.char_obj_list:
if _char_obj.CID == CID:
self.char_obj_dict[CID] = _char_obj
break
else:
raise ValueError(f"在构造普攻管理器时，未找到CID为{CID}的角色！")
if action == "auto_NA":
if CID not in self.na_manager_dict:
assert self.preload_data.char_data is not None
for _char_obj in self.preload_data.char_data.char_obj_list:
if _char_obj.CID == CID:
self.na_manager_dict[CID] = na_manager_factory(_char_obj)
break
else:
raise ValueError(f"在构造普攻管理器时，未找到CID为{CID}的角色！")
current_na_manager = self.na_manager_dict[CID]
# stack = self.preload_data.personal_node_stack.get(CID, None)
stack = self.preload_data.personal_active_generation_node_stack.get(CID, None)
if stack is None:
last_action = None
else:
last_action = stack.peek()
if last_action is None or CID != self.preload_data.operating_now:
"""没有第一个动作时，直接派生第一段普攻"""
output = current_na_manager.first_hit
else:
output = current_na_manager.spawn_out_na(last_action)
elif action == "assault_after_parry":
if CID in CHAR_PARRY_STRATEGY_MAP:
output = CHAR_PARRY_STRATEGY_MAP[CID]
else:
output = f"{CID}_Assault_Aid"
else:
output = action
char_obj = self.char_obj_dict[CID]
final_output = char_obj.personal_action_replace_strategy(action=output)
return final_output
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/CheckCID.py
================================================
import re
def check_cid(check_target):
if len(check_target) != 4 or not bool(re.match(r"^-?\d+$", check_target)):
"""检测self.check_target是否是4位int"""
raise ValueError(f"子条件中的CID格式不对！{check_target}")
# TODO: 应该在判断通过的同时输出CID！
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/CheckNumberType.py
================================================
def check_number_type(text):
"""
将文本的整型、浮点数、布尔值、元组转化为正常格式，纯文本不变、若是类型不是文本则直接输出。
:param text: 输入的参数，可能是文本或已经正确的类型
:return: 转换后的值
"""
if isinstance(text, str):
# 尝试转换为整型
try:
return int(text)
except ValueError:
pass
# 尝试转换为浮点数
try:
return float(text)
except ValueError:
pass
# 尝试转化None
if text.lower() == "none":
return None
# 尝试转换为布尔值
if text.lower() in ["true", "false"]:
return text.lower() == "true"
# 尝试转换为元组
if text.startswith("(") and text.endswith(")"):
try:
# 去除括号并分割元素
elements = text[1:-1].split(",")
# 递归处理每个元素
return tuple(check_number_type(elem.strip()) for elem in elements)[1]
except ValueError:
pass
# 如果以上转换都失败，返回原文本
return text
elif isinstance(text, tuple):
# 如果是元组，递归处理每个元素
return tuple(check_number_type(elem) for elem in text)[1]
else:
# 如果不是文本类型，直接返回
return text
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/FindBuff.py
================================================
def find_buff(game_state: dict, char, buff_index):
"""
根据buff的index来找到buff
通常用于判断“当前是否有该Buff激活”
"""
for buffs in game_state["global_stats"].DYNAMIC_BUFF_DICT[char.NAME]:
if buffs.ft.index == buff_index:
return buffs
else:
return None
# elif hasattr(data, key): # 处理类对象
# return get_nested_value(getattr(data, key), key_list[1:])
# else:
# raise ValueError(f'无法解析的数据类型！{data, type(data)}')
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/FindBuff_0.py
================================================
def find_buff_0(game_state: dict, char, buff_index):
"""
根据buff的index来找到buff
通常用于判断“当前是否有该Buff激活”
"""
for _buff_index, _buff in game_state["load_data"].exist_buff_dict[char.NAME].items():
if _buff_index == buff_index:
return _buff
else:
return None
# elif hasattr(data, key): # 处理类对象
# return get_nested_value(getattr(data, key), key_list[1:])
# else:
# raise ValueError(f'无法解析的数据类型！{data, type(data)}')
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/FindCharacter.py
================================================
def find_char(found_char_dict: dict, game_state: dict, CID: int):
"""
根据提供的CID，找到对应的char，并且返回、保存在self.found_char_dict中。
每次调用时，会先检查是否在self.found_char_dict中。如果找不到，再扔出去。
"""
if CID in found_char_dict.keys():
return found_char_dict[CID]
for char in game_state["char_data"].char_obj_list:
if char.CID == int(CID):
found_char_dict[char.CID] = char
return char
else:
raise ValueError(f"未找到CID为{CID}的角色！")
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/GetGameState.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
def get_game_state(sim_instance: "Simulator"):
"""获取game_state"""
return sim_instance.game_state
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/GetLastAction.py
================================================
from zsim.define import SWAP_CANCEL
def get_last_action(game_state: dict):
"""
注意，这个函数获取的应该是最新的主动动作的名称，
"""
if SWAP_CANCEL:
if game_state is None or game_state["preload"] is None:
return False
return game_state["preload"].preload_data.latest_active_generation_node
else:
last_node = getattr(game_state["preload"].preload_data, "last_node", None)
if last_node is None:
return None
output = last_node.skill_tag
return output
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/GetNestedValue.py
================================================
def get_nested_value(key_list: list, data):
"""递归获取嵌套结构中的值，一挖到底"""
if not key_list:
return data
if len(key_list) > 1:
key = key_list[0]
if isinstance(data, dict) and key in data:
return get_nested_value(data[key], key_list[1:])
elif isinstance(data, list | tuple) and isinstance(key, int) and 0 <= key < len(data):
return get_nested_value(data[key], key_list[1:])
elif len(key_list) == 1:
key = key_list[0]
if isinstance(data, dict) and key in data:
return data[key]
elif isinstance(data, list | tuple) and isinstance(key, int) and 0 <= key < len(data):
return data[key]
else:
raise ValueError(f"无法解析的数据类型！{data, type(data)}")
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/GetPersonalNodeStack.py
================================================
def get_personal_node_stack(game_state):
return game_state["preload"].preload_data.personal_node_stack
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLJudgeTools/__init__.py
================================================
from .CheckCID import check_cid
from .CheckNumberType import check_number_type
from .FindBuff import find_buff
from .FindBuff_0 import find_buff_0
from .FindCharacter import find_char
from .GetGameState import get_game_state
from .GetLastAction import get_last_action
from .GetNestedValue import get_nested_value
from .GetPersonalNodeStack import get_personal_node_stack
__all__ = [
"check_number_type",
"find_char",
"get_nested_value",
"find_buff",
"get_last_action",
"get_game_state",
"find_buff_0",
"check_cid",
"get_personal_node_stack",
]
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLManager.py
================================================
import os
from typing import TYPE_CHECKING, Optional
from zsim.define import COSTOM_APL_DIR, DEFAULT_APL_DIR
from .APLClass import APLClass
from .APLParser import APLParser
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
from .. import PreloadData
class APLManager:
"""APL管理器，用于管理和加载APL代码文件"""
def __init__(self, sim_instance: "Simulator | None" = None):
self.default_apl_dir = DEFAULT_APL_DIR
self.custom_apl_dir = COSTOM_APL_DIR
self._ensure_directories()
self.sim_instance = sim_instance
def _ensure_directories(self):
"""确保必要的目录存在"""
os.makedirs(self.default_apl_dir, exist_ok=True)
os.makedirs(self.custom_apl_dir, exist_ok=True)
def get_apl_path(self, name: str) -> Optional[str]:
"""
获取APL文件的完整路径
:param name: APL文件名（可以带或不带.txt后缀）
:return: 完整的文件路径，如果文件不存在则返回None
"""
if not name.endswith(".txt"):
name = f"{name}.txt"
# 按照优先级依次查找
search_paths = [
os.path.join(self.custom_apl_dir, name),
os.path.join(self.default_apl_dir, name),
]
for path in search_paths:
if os.path.exists(path):
return path
return None
def load_apl(self, path: str, mode: int, preload_data: "PreloadData") -> APLClass:
"""
加载并解析APL文件
:param path: APL文件路径
:param mode: 解析模式（0为普通模式，1为默认配置模式）
:param preload_data: 外部传入的Preload_data
:return: 已初始化的APLClass实例
"""
return APLClass(
APLParser(file_path=path).parse(mode=mode),
preload_data=preload_data,
sim_instance=self.sim_instance,
)
def list_available_apls(self) -> list[str]:
"""
列出所有可用的APL文件
:return: APL文件名列表
"""
apls = []
for directory in [self.default_apl_dir, self.custom_apl_dir]:
if os.path.exists(directory):
apls.extend([f for f in os.listdir(directory) if f.endswith(".txt")])
return list(set(apls)) # 去重
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLOperator.py
================================================
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
from ..apl_unit.ActionAPLUnit import ActionAPLUnit
from ..apl_unit.APLUnit import APLUnit
from ..PreloadDataClass import PreloadData
class APLOperator:
"""APL执行器，负责运行对象化的APL代码，并返回布尔值。"""
def __init__(
self,
all_apl_unit_list,
game_state: dict,
preload_data: "PreloadData",
simulator_instance: "Simulator" = None,
):
self.game_state = game_state
self.preload_data = preload_data
self.found_char_dict = {} # 用于装角色实例，键值是CID
self.leagal_apl_type_list = [
"action+=",
"action.no_swap_cancel+=",
"action.atk_response_positive+=",
"action.atk_response_balance+=",
]
self.sim_instance = simulator_instance
from zsim.sim_progress.Preload.apl_unit.APLUnit import APLUnit
self.apl_unit_inventory: dict[int, APLUnit] = {} # 用于装已经解析过的apl子条件实例。
for unit_dict in all_apl_unit_list:
self.apl_unit_inventory[unit_dict["priority"]] = self.apl_unit_factory(unit_dict)
# print(unit_dict["priority"], unit_dict)
def spawn_next_action_in_common_mode(self, tick) -> tuple[int, str, int, "ActionAPLUnit"]:
"""APL执行器的核心功能函数——筛选出优先级最高的下一个动作（普通模式）"""
atk_response_mode = self.preload_data.atk_manager.attacking
if atk_response_mode:
raise ValueError("在进攻响应模式下，不能调用spawn_next_action_in_common_mode方法！")
for priority, apl_unit in self.apl_unit_inventory.items():
from zsim.sim_progress.Preload.apl_unit.ActionAPLUnit import ActionAPLUnit
from zsim.sim_progress.Preload.apl_unit.AtkResponseAPLUnit import (
AtkResponseAPLUnit,
)
apl_unit: ActionAPLUnit | AtkResponseAPLUnit
if isinstance(apl_unit, AtkResponseAPLUnit):
continue
result, result_box = apl_unit.check_all_sub_units(
self.found_char_dict,
self.game_state,
tick=tick,
sim_instance=self.sim_instance,
preload_data=self.preload_data,
)
if not result:
# if priority in [1] and tick <= 1500:
# print(
# f"这次不通过的APL优先级为{priority}，内容为{apl_unit.result} 判定结果为：{result_box}"
# )
continue
else:
if apl_unit.break_when_found_action:
# print(
# f"APL找到了新的最高优先级的动作！优先级为：{apl_unit.priority}，输出动作：{apl_unit.result}"
# )
return (
int(apl_unit.char_CID),
apl_unit.result,
apl_unit.priority,
apl_unit,
)
else:
continue
else:
raise ValueError("没有找到符合要求的APL！")
def spawn_next_action_in_atk_response_mode(self, tick) -> tuple[int, str, int, "ActionAPLUnit"]:
"""APL执行器的核心功能函数——筛选出优先级最高的下一个动作（进攻响应模式）"""
if not self.preload_data.atk_manager.attacking:
raise ValueError(
"在非进攻响应模式下，不能调用spawn_next_action_in_atk_response_mode方法！"
)
from zsim.sim_progress.Preload.apl_unit.ActionAPLUnit import ActionAPLUnit
from zsim.sim_progress.Preload.apl_unit.AtkResponseAPLUnit import (
AtkResponseAPLUnit,
)
for priority, apl_unit in self.apl_unit_inventory.items():
if isinstance(apl_unit, ActionAPLUnit | AtkResponseAPLUnit):
result, result_box = apl_unit.check_all_sub_units(
self.found_char_dict,
self.game_state,
tick=tick,
sim_instance=self.sim_instance,
preload_data=self.preload_data,
)
if not result:
continue
else:
return (
int(apl_unit.char_CID),
apl_unit.result,
apl_unit.priority,
apl_unit,
)
else:
raise ValueError("没有找到符合要求的APL！")
def apl_unit_factory(self, apl_unit_dict) -> "APLUnit":
"""构造APL子单元的工厂函数"""
from zsim.sim_progress.Preload.apl_unit.ActionAPLUnit import ActionAPLUnit
from zsim.sim_progress.Preload.apl_unit.AtkResponseAPLUnit import (
AtkResponseAPLUnit,
)
if apl_unit_dict["type"] in ["action+=", "action.no_swap_cancel+="]:
return ActionAPLUnit(apl_unit_dict, sim_instance=self.sim_instance)
elif "action.atk_response" in apl_unit_dict["type"]:
return AtkResponseAPLUnit(apl_unit_dict=apl_unit_dict, sim_instance=self.sim_instance)
elif all(code_str in apl_unit_dict["type"] for code_str in ["a", "c", "t", "i", "o", "n"]):
raise ValueError(f"貌似是拼写错误，当前输入的APL类型为：{apl_unit_dict['type']}")
else:
raise ValueError(f"无法识别的APL类型：{apl_unit_dict['type']}")
# # Optimized Code:
#
# if "enemy" not in judge_code:
# return False
# path, operator, value = self._judge_code_spliter(judge_code)
# accessor = self._access_cache(path) # 缓存访问器
#
# # 获取实际数值
# target_value = accessor(self.game_state["schedule_data"])
# if target_value is None:
# return False
#
# # 执行比较操作（可扩展更多运算符）
# print("Debugging 1st", target_value, '2nd', value)
# return compare_methods_mapping[operator](target_value, type(target_value)(value)) # 保持类型一致
================================================
FILE: zsim/sim_progress/Preload/APLModule/APLParser.py
================================================
import os.path
import re
from typing import Sequence
class APLParser:
def __init__(self, apl_code: str | None = None, file_path: str | None = None):
# 如果传入APL代码，使用它；如果传入文件路径，则从文件中读取
if apl_code is not None:
self.apl_code = apl_code
elif file_path is not None:
self.apl_code = self._read_apl_from_file(file_path)
else:
raise ValueError("Either apl_code or file_path must be provided.")
@staticmethod
def _read_apl_from_file(file_path: str) -> str:
"""从文件中读取APL代码。"""
try:
# 检查文件扩展名
if file_path.endswith(".toml"):
import tomllib
with open(file_path, "rb") as f:
toml_dict: dict = tomllib.load(f)
# 如果存在apl_logic表的logic，返回其内容，否则返回空字符串
return toml_dict.get("apl_logic", {}).get("logic", "")
else:
# 非toml文件按原有方式处理
with open(file_path, "r", encoding="utf-8") as f:
return f.read()
except FileNotFoundError as e:
print(f"Error reading file {file_path}: {e}")
return ""
def parse(self, mode: int) -> list[dict[str, Sequence[str]]]:
"""
apl_code本来是一大串str，现在要通过这个函数，将其变为列表内含多字典的模式。
action下面存的应该是技能ID或是Skill的Triggle_Buff_Level，
而conditions下面存的则是发动动作的条件。
这一步应该在初始化的时候执行。
"""
actions = []
priority = 0
if mode == 0:
priority = 1
selected_char_cid = []
for line in self.apl_code.splitlines():
# 去除空白字符并清理行内注释
line = line.split("#", 1)[0].strip()
# 忽略空行
if not line:
continue
try:
if mode == 0:
# 0. 更新CID，
if int(line[:4]) not in selected_char_cid:
selected_char_cid.append(int(line[:4]))
# 1. 按 '|' 分割字符串
parts = line.split("|")
if len(parts) < 3:
raise ValueError(f"Invalid format: {line}")
# 2. 提取 CID
CID = parts[0]
apl_type = parts[1]
# 3. 提取 action_name 和条件部分
action_name = parts[2]
conditions = parts[3:] # 从第4个元素开始作为条件列表
# 兼容|作为与门表达式符号的逻辑,转为一整条表达式字符串,统一解析出子条件列表
condition_expression = " and ".join(conditions).strip()
conditions, logic_tree = parse_logical_expression(condition_expression)
# 4. 记录解析后的数据
actions.append(
{
"CID": CID,
"type": apl_type.strip(),
"action": action_name.strip(),
"conditions": [cond.strip() for cond in conditions if cond.strip()],
"conditions_tree": logic_tree, # dict表示的逻辑树结构
"priority": priority,
"whole_line": line,
}
)
if mode == 0:
priority += 1
except Exception as e:
print(f"Error parsing line: {line}, Error: {e}")
continue
if mode == 0:
"""
这个if分枝的功能是：部分角色可能因角色特性而存在一些默认优先级最高的行为，
在APL代码进行解析和拆分时，这些优先级最高的代码会被安插在所有APL的最前端。
如果某角色存在着优先级永远最高的默认手法，则可以用这个功能实现，把对应的APL逻辑写到DefaultConfig中即可。
但是注意，DefaultConfig中的所有APL代码均会以最高优先级进行执行，
所以一般情况下还是推荐对APL进行全面定制
"""
for cid in selected_char_cid:
dir_path = "./data/APLData/default_APL"
default_file_name = f"{cid}.txt"
full_path = dir_path + "/" + default_file_name
if not os.path.isfile(full_path):
continue
else:
default_action = APLParser(file_path=full_path).parse(mode=1)
actions[:0] = default_action
return renumber_priorities(actions)
def renumber_priorities(data_list):
seen = set() # 记录已使用的优先级值
current_max = -1 # 跟踪当前最大有效优先级
for item in data_list:
original = item["priority"]
# 策略1：优先保持原有数值（如果未被占用）
if original not in seen:
seen.add(original)
current_max = max(current_max, original)
# 策略2：分配当前最大+1（当原值已被占用时）
else:
current_max += 1
item["priority"] = current_max
seen.add(current_max)
return data_list
def tokenize(expression):
# 括号、and、or 分割，保留分隔符
return re.findall(r"\(|\)|\band\b|\bor\b|[^()\s]+", expression)
def extract_conditions(tokens):
# 提取子条件单元（非运算符和括号）
return sorted(set(t for t in tokens if t not in ("and", "or", "(", ")")))
def parse_expression(tokens):
"""解析逻辑表达式, 返回逻辑树结构, 优先级为()>and>or"""
if not tokens:
return None
def parse_factor(index):
"""解析基本因子：括号或单个条件"""
token = tokens[index]
if token == "(":
subtree, index = parse_or(index + 1)
if tokens[index] != ")":
raise ValueError("缺失右括号")
return subtree, index + 1
else:
return token, index + 1
def parse_and(index):
"""解析 and 级别表达式"""
left, index = parse_factor(index)
items = [left]
while index < len(tokens) and tokens[index] == "and":
right, index = parse_factor(index + 1)
items.append(right)
return {"and": items} if len(items) > 1 else items[0], index
def parse_or(index):
"""解析 or 级别表达式"""
left, index = parse_and(index)
items = [left]
while index < len(tokens) and tokens[index] == "or":
right, index = parse_and(index + 1)
items.append(right)
return {"or": items} if len(items) > 1 else items[0], index
tree, final_index = parse_or(0) # 从最低优先级开始解析
if final_index != len(tokens):
raise ValueError("无法解析整个表达式")
return tree
def parse_logical_expression(expr):
tokens = tokenize(expr)
conditions = extract_conditions(tokens)
logic_tree = parse_expression(tokens)
return conditions, logic_tree
if __name__ == "__main__":
code = "1211|action+=|1211_NA_1|status.enemy:stun==True and !buff.1091:exist→Buff-角色-丽娜-核心被动-穿透率==True"
# actions_list = APLParser(file_path=APL_PATH).parse(mode=0)
actions_list = APLParser(apl_code=code).parse(mode=0)
for sub_dict in actions_list:
print(sub_dict)
================================================
FILE: zsim/sim_progress/Preload/APLModule/ActionReplaceManager.py
================================================
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
from zsim.define import ENEMY_ATTACK_REPORT
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from zsim.sim_progress.data_struct.QuickAssistSystem import QuickAssistManager
if TYPE_CHECKING:
from zsim.sim_progress.data_struct.EnemyAttackEvent import EnemyAttackEventManager
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
class ActionReplaceManager:
"""
该对象主要用于阻塞、改写APL运行结果。
由于是非常粗暴的接在APL的对外输出函数上进行拦截、修正，
所以该对象的使用必须谨慎，以免大幅度影响APL手法的实现。
"""
def __init__(self, preload_data):
self.preload_data: "PreloadData" = preload_data
self.quick_assist_strategy = self.QuickAssistStrategy(self.preload_data)
self.parry_aid_strategy = self.ParryAidStrategy(self.preload_data)
def action_replace_factory(self, CID: int, action: str, tick: int) -> tuple[bool, str]:
"""该函数主要用于拦截APL的主动动作，使其被其他动作替代，用来模拟各种特殊情况"""
"""如果目前正处于黄光阶段（窗口期），那么此时的所有切人动作都会被无条件换成格挡，哪怕此时快支正处于激活状态"""
assert self.preload_data.sim_instance is not None
if "耀嘉音" in self.preload_data.sim_instance.init_data.name_box:
"""有耀嘉音时，优先检测快支替换"""
if self.quick_assist_strategy.condition_judge(CID=CID, action=action, tick=tick):
quick_assist_strategy_replace_result = self.quick_assist_strategy.spawn_new_action(
CID, action
)
if quick_assist_strategy_replace_result not in ["parry", "wait"]:
return True, quick_assist_strategy_replace_result
parry_replace_result = self.parry_aid_strategy.spawn_new_action(
CID=CID, action=action, tick=tick
)
if parry_replace_result != action:
return True, parry_replace_result
return False, action
else:
"""没有耀嘉音时，优先检测招架替换"""
parry_replace_result = self.parry_aid_strategy.spawn_new_action(
CID=CID, action=action, tick=tick
)
if parry_replace_result != action:
return True, parry_replace_result
if self.quick_assist_strategy.condition_judge(CID=CID, action=action, tick=tick):
quick_assist_strategy_replace_result = self.quick_assist_strategy.spawn_new_action(
CID, action
)
return True, quick_assist_strategy_replace_result
return False, action
class __BaseStrategy(ABC):
def __init__(self, preload_data: "PreloadData"):
self.preload_data: "PreloadData" = preload_data
@abstractmethod
def condition_judge(self, *args, **kwargs) -> bool | str:
pass
@abstractmethod
def spawn_new_action(self, *args, **kwargs) -> str:
pass
class QuickAssistStrategy(__BaseStrategy):
def __init__(self, preload_data):
super().__init__(preload_data)
self.manager_box: dict[int, "QuickAssistManager"] = {}
def condition_judge(self, CID: int, tick: int, action: str, *args, **kwargs) -> bool:
"""
该函数用于判定当前tick的动作是否需要被替换成快速支援：条件如下：
1、当前角色快速支援亮起
2、当前角色企图从后台切到前台
"""
if CID is None or action is None:
raise ValueError("CID或action为空！")
if self.preload_data.quick_assist_system is None:
"""如果快速支援系统的对象还未建立，那么说明此时
根本不可能有导致快速支援替换APL动作的情况发生，直接返回False即可。"""
return False
if CID not in self.manager_box:
for (
manager
) in self.preload_data.quick_assist_system.quick_assist_manager_group.values():
if manager.char.CID == CID:
self.manager_box[CID] = manager
break
else:
raise ValueError(f"没有找到{CID}角色的快速支援管理器！")
current_manager = self.manager_box[CID]
node_on_field = self.preload_data.get_on_field_node(tick - 1)
"""注意，这里传入tick-1的作用：当某些技能不能被合轴与终止时（比如QTE和Q），新动作会被SwapCancelEngine一直拦截，
此时，就会出现1帧时间场上没有任何动作，这会导致调用该函数的一些判断出错。所以将时间提前了1帧，规避这些错误。"""
if node_on_field is None:
# FIXME:这里还是有问题，程序中有时会出现的current_node_on_field 为None的情况，一定会干扰模拟的进行，必须找时间解决掉！
return False
"""当前角色的快速支援正处于激活状态，并且角色企图上场释放技能，则执行替换。"""
if current_manager.quick_assist_available and str(CID) not in node_on_field.skill_tag:
return True
else:
return False
def spawn_new_action(self, CID: int, action: str) -> str:
if action == "wait":
return action
for _obj in self.preload_data.skills:
if _obj.CID != CID:
continue
if "parry" in action:
do_immediately_info = True
elif action == "auto_NA":
do_immediately_info = False
else:
do_immediately_info = _obj.get_skill_info(
skill_tag=action, attr_info="do_immediately"
)
if do_immediately_info:
return action
else:
manager = self.manager_box[CID]
# print(f'执行快速支援！技能{action}替换成了{manager.quick_assist_skill}！')
return manager.quick_assist_skill
else:
raise ValueError(f"没有找到CID为{CID}的技能对象！无法执行快速支援替换！")
class ParryAidStrategy(__BaseStrategy):
"""负责将技能tag替换成各类招架支援的结构"""
def __init__(self, preload_data):
super().__init__(preload_data)
self.consecutive_parry_mode: bool = False # 连续招架模式
self.consecutive_parry_node: "SkillNode | None" = None # 连续招架的技能节点
self.parry_interaction_in_progress: bool = False # 当前轮次招架交互正在进行
self.parry_tag: str | None = None # 当前轮次招架交互的招架技能标签。
from zsim.define import PARRY_BASE_PARAMETERS
self.chain_parry_tick = PARRY_BASE_PARAMETERS[
"ChainParryActionTimeCost"
] # 系统默认的连续招架时间消耗
self._knock_back_signal = False # 击退信号，在末次招架结算时，会由外部数据结构操作接口函数打开，并且在抛出击退信号后置为False
self.final_parry_node: "SkillNode | None" = None
"""每次招架后，角色都会获得一次突击支援的机会，但是衔接突击支援的时间是有要求的，必须在突击支援失效之前进行（角色击退时间）"""
self.assault_aid_disable_tick: int = 0
self.assault_aid_enable: bool = False
@property
def knock_back_signal(self) -> bool:
return self._knock_back_signal
@knock_back_signal.setter
def knock_back_signal(self, value: bool):
# print(f"【ActionReplaceManager】knock_back_signal被重新赋值为{value}")
self._knock_back_signal = value
def condition_judge(self, CID: int, tick: int, action: str, *args, **kwargs) -> bool | str:
"""
用来判断当前情景下，APL抛出的技能tag是否需要被强制替换为对应的招架类Tag。
"""
if self.knock_back_signal:
return "knock_back"
atk_manager = self.preload_data.atk_manager
if atk_manager is None:
return False
char_on_field_cid = self.preload_data.operating_now
if not atk_manager.attacking and not self.knock_back_signal:
return False
# 对于命中次数为0的进攻事件，应该将其送入【首次招架分支】：
if atk_manager.hitted_count == 0:
# 审查招架角色是否拥有招架的能力，是否满足招架的基本条件，同时时间窗口又是否允许？
if self.__first_parry_condition_judge(
atk_manager=atk_manager,
CID=CID,
tick=tick,
action=action,
char_on_field_cid=char_on_field_cid,
):
return "first_parry"
else:
# 命中次数不为0的情况，主要分为两种：【连续招架】以及【单次招架的后续】。
if self.consecutive_parry_mode:
# 若连续招架的开关打开，那么无需任何函数判定，都放行并且返回【连续招架】的更新信号
assert atk_manager.action is not None
if atk_manager.hitted_count == atk_manager.action.hit - 1:
return "final_parry"
else:
return "consecutive_parry"
# else:
# # 若连续招架开关关闭，那么则是【单次招架后续】分支，这里需要考虑是否要抛出“KnockBack”技能，模拟角色被击退。
# if self.knock_back_signal:
# return "knock_back"
return False
def __first_parry_condition_judge(
self,
atk_manager: "EnemyAttackEventManager",
CID: int,
tick: int,
action: str,
char_on_field_cid: int | None,
) -> bool:
"""
判断当前情况是否满足第一次招架。条件有：
0、当前有激活的进攻事件并且结算次数为0（已前置）
1、有角色正尝试切换到前台
2、该角色拥有招架能力
3、时间窗口合法
"""
# 条件1检查——角色尝试切换到前台
if char_on_field_cid is not None:
if char_on_field_cid == CID:
return False
# 条件2检查——角色有招架能力
if self.preload_data.sim_instance is None:
return False
char_obj = self.preload_data.sim_instance.char_data.find_char_obj(CID=CID)
if char_obj is None:
return False
if char_obj.aid_type != "招架":
if "parry" in action.lower():
raise ValueError(
f"APL尝试让 {char_obj.NAME} 进行招架操作，但是该角色没有招架能力！"
)
return False
# 条件3检查——时间窗口合法
if not atk_manager.is_in_response_window(tick=tick):
return False
else:
return True
def spawn_new_action(self, CID: int, action: str, tick: int, *args, **kwargs) -> str:
"""根据当前的状态，执行招架支援tag的替换。"""
replace_signal: bool | str = self.condition_judge(CID=CID, action=action, tick=tick)
# 若条件判断返回的是False，则说明不执行替换，返回原始tag。
if not replace_signal:
return action
atk_manager = self.preload_data.atk_manager
assert atk_manager is not None
if replace_signal == "first_parry":
return self.__first_parry_replace_handler(
atk_manager=atk_manager, CID=CID, action=action, tick=tick
)
elif replace_signal == "consecutive_parry":
return self.__consecutive_parry_replace_handler(
atk_manager=atk_manager, CID=CID, action=action, tick=tick
)
elif replace_signal == "knock_back":
return self.__knock_back_replace_handler(CID=CID)
elif replace_signal == "final_parry":
return self.__final_parry_replace_handler(atk_manager=atk_manager, CID=CID)
else:
raise ValueError(f"无法识别的替换信号：{replace_signal}！")
def spawn_parry_aid_tag(self, CID: int, mode: int) -> str:
if mode == 0:
return f"{CID}_Light_parry_Aid"
elif mode == 1:
assert self.consecutive_parry_node is not None
return (
f"{self.consecutive_parry_node.skill_tag.strip().split('_')[0]}_Chain_parry_Aid"
)
elif mode == 2:
assert self.consecutive_parry_node is not None
return (
f"{self.consecutive_parry_node.skill_tag.strip().split('_')[0]}_Heavy_parry_Aid"
)
elif mode == 3:
"""这是衔接在招架支援后的后退动作，无法取消。"""
assert self.final_parry_node is not None
return f"{self.final_parry_node.skill_tag.strip().split('_')[0]}_knock_back_cause_parry"
else:
raise ValueError(f"不支持的招架模式：{mode}！")
def __first_parry_replace_handler(
self,
atk_manager: "EnemyAttackEventManager",
CID: int,
action: str,
tick: int,
) -> str:
"""负责处理“首次招架”分支的tag替换业务"""
# 注意，执行本函数的情况，正常情况下总是符合时间窗口的(APL和前方的信号函数都已经处理过这个逻辑了
if not atk_manager.is_in_response_window(tick=tick):
raise ValueError("首次招架的技能标签替换失败，因为当前时间窗口已经过期！")
if atk_manager.action is None:
raise ValueError("atk_manager.action is None, but it should not be.")
if atk_manager.action.hit_type in ["Light", "Chain"]:
return self.spawn_parry_aid_tag(CID=CID, mode=0)
elif atk_manager.action.hit_type == "Heavy":
return self.spawn_parry_aid_tag(CID=CID, mode=2)
else:
raise ValueError(f"不支持的招架技能类型：{atk_manager.action.hit_type}！")
def __consecutive_parry_replace_handler(
self,
atk_manager: "EnemyAttackEventManager",
CID: int,
action: str,
tick: int,
) -> str:
"""
负责处理“连续招架”分支的tag替换业务
当处于连续招架的情况下，应该在窗口合法时，第一时间抛出连续招架，
若时间窗口尚未到来，则抛出wait，
"""
settled_tick = tick + self.chain_parry_tick
if atk_manager.hit_check(int(settled_tick)):
return self.spawn_parry_aid_tag(CID=CID, mode=1)
else:
return "wait"
def __knock_back_replace_handler(self, CID: int) -> str:
"""
负责处理“KnockBack”分支的tag替换业务
该分支的职能是：准确识别“击退信号”并且抛出“击退”动作。
首先，在检测到被击退信号之前，应当保持输出wait，
而在识别到被击退信号之后，输出knock_back
"""
if self.knock_back_signal:
return self.spawn_parry_aid_tag(CID=CID, mode=3)
else:
raise ValueError("并未检测到击退信号！请检查函数逻辑！")
def __final_parry_replace_handler(self, CID: int, atk_manager: "EnemyAttackEventManager"):
"""
负责处理“final_parry”分支的tag替换业务
该分支的职能是：复核验证最后一击的判定结果，
同时根据本次进攻信号的数量，抛出对应的tag
"""
assert atk_manager.action is not None
if atk_manager.hitted_count > atk_manager.action.hit - 1:
raise ValueError(
"当前已结算次数与进攻信号的命中次数不匹配！这种情况理应不该送入“final_parry”分支，请检查函数逻辑。"
)
if atk_manager.action.hit < 3:
return self.spawn_parry_aid_tag(CID=CID, mode=1)
else:
return self.spawn_parry_aid_tag(CID=CID, mode=2)
def update_myself(self, skill_node: "SkillNode", tick: int):
"""开放给外部的更新窗口"""
if skill_node.skill.trigger_buff_level not in [7, 8, 9]:
if "knock_back" not in skill_node.skill_tag:
return
if "Light_parry" in skill_node.skill_tag:
self.parry_interaction_in_progress = True
if ENEMY_ATTACK_REPORT:
if self.preload_data.sim_instance:
self.preload_data.sim_instance.schedule_data.change_process_state()
print(
f"检测到来自于{skill_node.char_name}的招架技能{skill_node.skill_tag}！招架交互开始！"
)
assert self.preload_data.atk_manager is not None
assert self.preload_data.atk_manager.action is not None
if self.preload_data.atk_manager.action.hit > 1:
self.consecutive_parry_mode = True
self.consecutive_parry_node = skill_node
print("当前进攻事件是多次命中的，所以开启连续招架模式！")
elif "knock_back" in skill_node.skill_tag:
if ENEMY_ATTACK_REPORT:
if self.preload_data.sim_instance:
self.preload_data.sim_instance.schedule_data.change_process_state()
print(f"角色 {skill_node.char_name} 因招架而被击退！")
self.knock_back_signal = False
self.final_parry_node = None
self.parry_interaction_in_progress = False
self.assault_aid_enable = True
self.assault_aid_disable_tick = tick + 60
if self.preload_data.sim_instance:
listener_manager = self.preload_data.sim_instance.listener_manager
listener_manager.broadcast_event(event=skill_node, signal=LBS.PARRY)
elif "Assault_Aid" in skill_node.skill_tag:
if tick > self.assault_aid_disable_tick:
raise ValueError(
f"{skill_node.char_name} 企图释放支援突击，但支援突击早就在{self.assault_aid_disable_tick}tick失效！请检查函数逻辑！"
)
self.assault_aid_enable = False
self.assault_aid_disable_tick = tick
if ENEMY_ATTACK_REPORT:
if self.preload_data.sim_instance:
self.preload_data.sim_instance.schedule_data.change_process_state()
print(f"角色 {skill_node.char_name} 在招架完成后释放支援突击！")
elif any(
[_sub_tag in skill_node.skill_tag for _sub_tag in ["Chain_parry", "Heavy_parry"]]
):
# 在检测连续招架或是重招架时，必须检测当前的命中次数，确保正确关闭连续招架状态。
assert self.preload_data.atk_manager is not None
assert self.preload_data.atk_manager.action is not None
if (
self.preload_data.atk_manager.hitted_count
== self.preload_data.atk_manager.action.hit
):
self.consecutive_parry_mode = False
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/ActionSubUnit.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.Preload.APLModule.APLJudgeTools import (
check_cid,
get_personal_node_stack,
)
from zsim.sim_progress.Preload.APLModule.SubConditionUnit import BaseSubConditionUnit
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
from ... import PreloadClass
from ...APLModule.ActionReplaceManager import ActionReplaceManager
from ...PreloadDataClass import PreloadData
class ActionSubUnit(BaseSubConditionUnit):
def __init__(self, priority: int, sub_condition_dict: dict = None, mode=0):
super().__init__(priority=priority, sub_condition_dict=sub_condition_dict, mode=mode)
class ActionCheckHandler:
@classmethod
def handler(cls, *args, **kwargs):
raise NotImplementedError
class LatestActionTagHandler(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> str | None:
preload_data: "PreloadData" = game_state["preload"].preload_data
lastest_node = preload_data.latest_active_generation_node
if lastest_node is None:
return None
if lastest_node.end_tick >= tick:
return lastest_node.skill_tag
else:
return None
class StrictLinkedHandler(ActionCheckHandler):
"""强衔接判定，技能skill_tag符合的同时，还需要上一个动作刚好结束。"""
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> str | None:
char_stack = get_personal_node_stack(game_state).get(char_cid, None)
if char_stack is None:
return None
else:
for i in range(char_stack.length):
current_node = char_stack.peek_index(i + 1)
if current_node is None:
return None
if (
current_node.skill.labels is not None
and "additional_damage" in current_node.skill.labels
):
continue
if current_node.end_tick != tick:
return None
return current_node.skill_tag
else:
return None
class LenientLinkedHandler(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> str | None:
char_stack = get_personal_node_stack(game_state).get(char_cid, None)
if char_stack is None:
return None
for i in range(char_stack.length):
current_node = char_stack.peek_index(i)
if current_node is None:
return None
if (
current_node.skill.labels is not None
and "additional_damage" in current_node.skill.labels
):
continue
else:
return current_node.skill_tag
else:
return None
class PositiveLinkedHander(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> str | None:
"""
积极衔接判定，技能skill_tag符合的同时，
只要上一个动作没有结束，就尝试进行衔接！
一般用于上一个节能可以被自己技能打断的情况，比如闪避。
"""
char_stack = get_personal_node_stack(game_state).get(char_cid, None)
if char_stack is None:
return None
for i in range(char_stack.length):
current_node = char_stack.peek_index(i + 1)
if current_node is None:
return None
if (
current_node.skill.labels is not None
and "additional_damage" in current_node.skill.labels
):
continue
if current_node.end_tick >= tick:
return current_node.skill_tag
else:
return None
class FirstActionHandler(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> bool:
char_stack = get_personal_node_stack(game_state).get(char_cid, None)
if char_stack is None:
return True
else:
current_node = char_stack.peek()
if current_node is None:
return True
return False
class IsPerformingHandler(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> None | str:
"""该函数的主要作用是尝试获取角色正在释放的某个技能的skill_tag。如果角色现在有空，则直接返回None"""
char_stack = get_personal_node_stack(game_state).get(char_cid, None)
if char_stack is None:
return None
last_node = char_stack.peek()
if last_node is None:
return None
else:
if last_node.end_tick >= tick:
return last_node.skill_tag
else:
return None
class DuringParryHandler(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> bool:
"""该函数主要作用是判断当前角色是否正处于进攻交互阶段（招架、或者被击退）"""
preload: "PreloadClass" = game_state["preload"]
action_replace_manager: "ActionReplaceManager" = (
preload.strategy.apl_engine.apl.action_replace_manager
)
if action_replace_manager is None:
return False
parry_strategy = action_replace_manager.parry_aid_strategy
return parry_strategy.parry_interaction_in_progress
class AssaultAidEnableHandler(ActionCheckHandler):
@classmethod
def handler(cls, char_cid: int, game_state, tick: int) -> bool:
"""该函数主要用于检查，当前角色的“支援突击”是否处于激活可用状态"""
preload: "PreloadClass" = game_state["preload"]
action_replace_manager: "ActionReplaceManager" = (
preload.strategy.apl_engine.apl.action_replace_manager
)
if action_replace_manager is None:
return False
assault_aid_enable = action_replace_manager.parry_aid_strategy.assault_aid_enable
return assault_aid_enable
ActionHandlerMap = {
"skill_tag": LatestActionTagHandler,
"strict_linked_after": StrictLinkedHandler,
"lenient_linked_after": LenientLinkedHandler,
"positive_linked_after": PositiveLinkedHander,
"first_action": FirstActionHandler,
"is_performing": IsPerformingHandler,
"during_parry": DuringParryHandler,
"assault_aid_enable": AssaultAidEnableHandler,
}
def check_myself(
self,
found_char_dict,
game_state,
sim_instance: "Simulator" = None,
*args,
**kwargs,
):
"""处理 动作判定类 的子条件"""
handler_cls = self.ActionHandlerMap.get(self.check_stat)
handler = handler_cls() if handler_cls else None
if not handler:
raise ValueError(
f"当前检查的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！"
)
if self.check_target in ["after", "team"]:
return self.spawn_result(handler.handler(game_state))
else:
"""check_target 不是 after（其实已经弃用了），就是CID"""
check_cid(self.check_target)
char_cid = int(self.check_target)
tick = sim_instance.tick
handler_result = handler.handler(char_cid, game_state, tick)
# if handler_result is not None:
# print(tick, f"APL优先级为：{self.priority}", self.check_value, handler_result)
result = self.spawn_result(handler_result)
return result
# if self.check_stat == 'skill_tag':
# checked_value = get_last_action(game_state)
# return self.spawn_result(checked_value)
# else:
# raise ValueError(f'子条件中的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！')
# else:
# raise ValueError(f'子条件中的check_target为：{self.check_target}，优先级为{self.priority}，暂无处理该目标类型的逻辑模块！')
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/AttributeSubUnit.py
================================================
from ...APLModule.APLJudgeTools import check_cid, get_nested_value
from ...APLModule.SubConditionUnit import BaseSubConditionUnit
class AttributeSubUnit(BaseSubConditionUnit):
def __init__(self, priority: int, sub_condition_dict: dict = None, mode=0):
super().__init__(priority=priority, sub_condition_dict=sub_condition_dict, mode=mode)
self.char = None
class AttributeCheckHandler:
@classmethod
def handler(cls, *args, **kwargs):
raise NotImplementedError
class EnergyHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, **kwargs):
return char.sp
class DecibelHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, **kwargs):
return char.decibel
class SpecialResourceValueHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, **kwargs):
return char.get_resources()[1]
class SpecialResourceTypeHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, **kwargs):
return char.get_resources()[0]
class SpecialStateHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, nested_stat_key_list: list = None, **kwargs):
if nested_stat_key_list:
return get_nested_value(nested_stat_key_list, char.get_special_stats())
else:
return char.get_special_stats()
class CinemaHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, **kwargs):
return char.cinema
class AdrenalineHandler(AttributeCheckHandler):
@classmethod
def handler(cls, char, **kwargs):
if not hasattr(char, "adrenaline"):
raise AttributeError(f"尝试在角色{char.NAME}中访问闪能！")
return char.adrenaline
AttributeHandlerMap = {
"energy": EnergyHandler,
"decibel": DecibelHandler,
"special_resource": SpecialResourceValueHandler,
"special_resource_type": SpecialResourceTypeHandler,
"special_state": SpecialStateHandler,
"cinema": CinemaHandler,
"adrenaline": AdrenalineHandler,
}
def check_myself(self, found_char_dict, game_state: dict, *args, **kwargs):
"""处理 属性判定类 的子条件"""
tick = kwargs.get("tick", None)
check_cid(self.check_target)
if self.char is None:
from zsim.sim_progress.Preload import find_char
self.char = find_char(found_char_dict, game_state, int(self.check_target))
handler_cls = self.AttributeHandlerMap.get(self.check_stat)
handler = handler_cls() if handler_cls else None
if not handler:
raise ValueError(
f"当前检查的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！"
)
if self.check_stat != "special_state":
return self.spawn_result(handler.handler(self.char, tick=tick))
else:
return self.spawn_result(
handler.handler(self.char, self.nested_stat_key_list, tick=tick)
)
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/BaseSubConditionUnit.py
================================================
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
from ...APLModule.APLJudgeTools import check_number_type
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class BaseSubConditionUnit(ABC):
def __init__(self, priority: int, sub_condition_dict: dict = None, mode=0):
"""单个APL判断条件的对象基类。"""
self.logic_mode = mode # mode 为1 时为反逻辑
self.priority = priority # 优先级
if sub_condition_dict is None:
self.no_condition = True # 无条件
else:
self.no_condition = False
self.check_target = sub_condition_dict["target"] # 检查目标 比如enemy，self，或者角色ID
self.check_stat = None
self.nested_stat_key_list = []
"""
在check_stat难免会碰到多层的嵌套结构，在APL中，统一用'→'来表示嵌套结构，这个list就是用来装这些嵌套的key的。
目前，nested_stat_key_list只为char.get_special_states函数服务
"""
if "→" in sub_condition_dict["stat"]: # 被检查的参数，这里有很多，不一一列举。
self.check_stat = sub_condition_dict["stat"].split("→")[0]
self.nested_stat_key_list = sub_condition_dict["stat"].split("→")[1:]
else:
self.check_stat = sub_condition_dict["stat"]
self.operation_type = sub_condition_dict["operation_type"] # 计算类型，主要是比较符和调用符
self.check_value = check_number_type(
sub_condition_dict["value"]
) # 参与计算的值 或者调用的函数名
@abstractmethod
def check_myself(
self,
found_char_dict,
game_state,
sim_instance: "Simulator" = None,
*args,
**kwargs,
):
pass
def spawn_result(self, value=None, **kwargs):
"""根据self.operation_type中的匿名函数来输出结果的函数"""
# value = check_number_type(value)
# assert value is not None, f"优先级为 {self.priority} 的子条件单元检查结果为 None， {self.check_stat}"
result = self.operation_type(value, self.check_value)
# if self.priority == 11 and result:
# import inspect
# print(f'{self.priority}_result：{value, self.check_value, inspect.getsource(self.operation_type).strip(), result}')
return self.translate_result(result)
def translate_result(self, result):
if self.logic_mode == 0:
return result
else:
return not result
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/BuffSubUnit.py
================================================
from zsim.sim_progress.Preload.APLModule.APLJudgeTools import (
check_cid,
find_buff,
find_buff_0,
)
from zsim.sim_progress.Preload.APLModule.SubConditionUnit import BaseSubConditionUnit
class BuffSubUnit(BaseSubConditionUnit):
def __init__(self, priority: int, sub_condition_dict: dict = None, mode=0):
super().__init__(priority=priority, sub_condition_dict=sub_condition_dict, mode=mode)
self.buff_0 = None
self.char = None
self.apl_warnning_dict = {}
class BuffCheckHandler:
@classmethod
def handler(cls, *args, **kwargs):
raise NotImplementedError
class BuffExistHandler(BuffCheckHandler):
@classmethod
def handler(cls, game_state, char, buff_0):
search_result = find_buff(game_state, char, buff_0.ft.index)
if search_result is not None:
return True
else:
return False
class BuffCountHandler(BuffCheckHandler):
@classmethod
def handler(cls, game_state, char, buff_0):
search_result = find_buff(game_state, char, buff_0.ft.index)
if search_result is not None:
return search_result.dy.count
else:
return 0
class BuffDurationHandler(BuffCheckHandler):
@classmethod
def handler(cls, game_state, char, buff_0):
search_result = find_buff(game_state, char, buff_0.ft.index)
if search_result is None:
return 0
tick = char.sim_instance.tick
return max(search_result.dy.endticks - tick, 0)
BuffHandlerMap = {
"exist": BuffExistHandler,
"count": BuffCountHandler,
"duration": BuffDurationHandler,
}
def check_myself(self, found_char_dict, game_state, *args, **kwargs):
check_cid(self.check_target)
if self.char is None:
from zsim.sim_progress.Preload import find_char
self.char = find_char(found_char_dict, game_state, int(self.check_target))
if self.buff_0 is None:
buff_index = self.nested_stat_key_list[0]
search_resurt = find_buff_0(game_state, self.char, buff_index)
if search_resurt is not None:
self.buff_0 = search_resurt
else:
if self.priority not in self.apl_warnning_dict:
print(
f"【非法APL警告】优先级为{self.priority}的APL似乎与当前模拟条件不匹配！原因：在{self.char.NAME}身上并未找到名为{buff_index}的Buff！"
)
self.apl_warnning_dict[self.priority] = True
return False
handler_cls = self.BuffHandlerMap[self.check_stat]
handler = handler_cls() if handler_cls else None
if not handler:
raise ValueError(
f"当前检查的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！"
)
return self.spawn_result(handler.handler(game_state, self.char, self.buff_0))
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/SpecialSubUnit.py
================================================
from typing import TYPE_CHECKING
from .BaseSubConditionUnit import BaseSubConditionUnit
if TYPE_CHECKING:
from ...PreloadDataClass import PreloadData
class SpecialSubUnit(BaseSubConditionUnit):
def __init__(self, priority: int, sub_condition_dict: dict = None, mode=0):
super().__init__(priority=priority, sub_condition_dict=sub_condition_dict, mode=mode)
self.preload_data = None
class SpecialHandler:
@classmethod
def handler(cls, *args, **kwargs):
raise NotImplementedError
class OperatingCharacterHandler(SpecialHandler):
@classmethod
def handler(cls, preload_data):
cid = preload_data.operating_now
# print(f'调用了特殊检查，当前正在操作的CID为：{cid}，当前被检测的技能为：{preload_data.latest_active_generation_node.skill_tag}')
return cid
class IsAttackingHandler(SpecialHandler):
@classmethod
def handler(cls, preload_data: "PreloadData"):
atk_manager = preload_data.atk_manager
if atk_manager is None:
return False
return atk_manager.attacking
SpecialHandlerMap = {
"operating_char": OperatingCharacterHandler,
"is_attacking": IsAttackingHandler,
}
def check_myself(self, found_char_dict, game_state, *args, **kwargs):
if self.preload_data is None:
preload = game_state.get("preload", None)
if preload is None:
raise ValueError(
"为从gamestate中获取到preload数据，请检查game_state的preload数据是否正常！"
)
self.preload_data = preload.preload_data
handler_cls = self.SpecialHandlerMap.get(self.check_stat)
handler = handler_cls() if handler_cls else None
if not handler:
raise ValueError(
f"当前检查的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！"
)
__result = self.spawn_result(handler.handler(self.preload_data))
# if __result and self.priority == 6:
# print(handler.handler(self.preload_data)), print(self.preload_data.latest_active_generation_node.skill_tag)
return __result
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/StatusSubUnit.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.Buff.JudgeTools import find_tick
from zsim.sim_progress.Preload.APLModule.APLJudgeTools.FindCharacter import find_char
from .BaseSubConditionUnit import BaseSubConditionUnit
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class StatusSubUnit(BaseSubConditionUnit):
def __init__(self, priority: int, sub_condition_dict: dict = None, mode=0):
super().__init__(priority=priority, sub_condition_dict=sub_condition_dict, mode=mode)
self.enemy = None
class CheckHandler:
@classmethod
def handler(cls, *args, **kwargs):
raise NotImplementedError
class StunHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.stun
class QTETriggerableHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.qte_manager.qte_data.qte_triggerable_times
class QTETriggeredHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.qte_manager.qte_data.qte_triggered_times
class QTEActivationAvailableHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.qte_manager.qte_data.qte_activation_available
class AnomalyPctHandler(CheckHandler):
def __init__(self, anomaly_number):
self.anomaly_number = anomaly_number
def handler(self, enemy):
return enemy.anomaly_bars_dict[self.anomaly_number].get_buildup_pct()
class BuildupPctHandler(CheckHandler):
def __init__(self, element_type_1: int, element_type_2: int):
self.element_type_1 = element_type_1
self.element_type_2 = element_type_2
def handler(self, enemy):
result = (
enemy.anomaly_bars_dict[self.element_type_1].get_buildup_pct()
- enemy.anomaly_bars_dict[self.element_type_2].get_buildup_pct()
)
return result
class StunPctHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.get_stun_percentage()
class CharLastingNodeTagHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
tick = find_tick(sim_instance=sim_instance)
char = find_char(found_char_dict, game_state, char_cid)
return char.dynamic.lasting_node.spamming_info(tick)[1]
class CharLastingNodeTickHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
tick = find_tick(sim_instance=sim_instance)
char = find_char(found_char_dict, game_state, char_cid)
return char.dynamic.lasting_node.spamming_info(tick)[2]
class CharRepeatTimesHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
tick = find_tick(sim_instance=sim_instance)
char = find_char(found_char_dict, game_state, char_cid)
return char.dynamic.lasting_node.spamming_info(tick)[3]
class CharOnFieldHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
char = find_char(found_char_dict, game_state, char_cid)
result = char.dynamic.on_field
return result
class SingleQTEHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.qte_manager.qte_data.single_qte
class CharAvailableHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
char = find_char(found_char_dict, game_state, char_cid)
return char.is_available(find_tick(sim_instance=sim_instance))
class QuickAssistHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
char = find_char(found_char_dict, game_state, char_cid)
quick_assist_available = char.dynamic.quick_assist_manager.quick_assist_available
from zsim.sim_progress.Character.character import Character
from zsim.simulator.simulator_class import Simulator
assert isinstance(char, Character)
assert isinstance(sim_instance, Simulator)
tick = sim_instance.tick
if not char.is_available(tick=tick):
return False
# 这里需要进一步审查，如果当前角色快速支援亮起但是角色本身有动作，那么这里应该返回False，即“快速支援激活但不能被响应”
preload_data = sim_instance.preload.preload_data
char_node_stack = preload_data.personal_node_stack.get(char_cid, None)
if char_node_stack is None:
return quick_assist_available
else:
for nodes in char_node_stack.stack:
if not nodes.active_generation or nodes.is_additional_damage:
continue
if tick <= nodes.end_tick:
return False
return quick_assist_available
class WaitingAssistHandler(CheckHandler):
@classmethod
def handler(cls, char_cid, found_char_dict, game_state, sim_instance):
char = find_char(found_char_dict, game_state, char_cid)
return char.dynamic.quick_assist_manager.assist_waiting_for_anwser(
find_tick(sim_instance=sim_instance)
)
class ActiveAnomalyHandler(CheckHandler):
@classmethod
def handler(cls, enemy, *args, **kwargs):
return enemy.dynamic.is_under_anomaly()
class ShockHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.shock
class BurnHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.burn
class AssultHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.assault
class FrostbiteHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.frostbite
class FrostFrostbiteHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.frost_frostbite
class CorruptionHandler(CheckHandler):
@classmethod
def handler(cls, enemy):
return enemy.dynamic.corruption
HANDLE_MAP = {
"stun": StunHandler,
"QTE_triggerable_times": QTETriggerableHandler, # 可连携次数
"QTE_triggered_times": QTETriggeredHandler, # 已连携次数
"anomaly_pct": AnomalyPctHandler,
"lasting_node_tag": CharLastingNodeTagHandler,
"lasting_node_tick": CharLastingNodeTickHandler,
"on_field": CharOnFieldHandler,
"QTE_activation_available": QTEActivationAvailableHandler, # 彩色失衡状态
"single_qte": SingleQTEHandler,
"repeat_times": CharRepeatTimesHandler,
"stun_pct": StunPctHandler,
"char_available": CharAvailableHandler,
"is_under_anomaly": ActiveAnomalyHandler,
"is_shock": ShockHandler,
"is_burn": BurnHandler,
"is_assault": AssultHandler,
"is_frostbite": FrostbiteHandler,
"is_frost_frostbite": FrostFrostbiteHandler,
"is_corruption": CorruptionHandler,
"quick_assist_available": QuickAssistHandler,
"assist_waiting_for_anwser": WaitingAssistHandler,
"buildup_pct_delta": BuildupPctHandler,
}
def check_myself(
self,
found_char_dict,
game_state,
sim_instance: "Simulator" = None,
*args,
**kwargs,
):
if self.check_target == "enemy":
if self.enemy is None:
self.enemy = game_state["schedule_data"].enemy
if "anomaly_pct" in self.check_stat:
anomaly_number = int(self.check_stat[-1])
handler = self.HANDLE_MAP["anomaly_pct"](anomaly_number)
elif "buildup_pct_delta" in self.check_stat:
stat_str = self.check_stat.strip().split("_")
anomaly_number_1 = int(stat_str[-1])
anomaly_number_2 = int(stat_str[-2])
handler = self.HANDLE_MAP["buildup_pct_delta"](anomaly_number_1, anomaly_number_2)
else:
handler_cls = self.HANDLE_MAP.get(self.check_stat)
handler = handler_cls() if handler_cls else None
if not handler:
raise ValueError(
f"当前检查的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！"
)
return self.spawn_result(handler.handler(self.enemy))
else:
"""既然check_target不是Enemy，那么一定是char的CID"""
handler_cls = self.HANDLE_MAP.get(self.check_stat)
handler = handler_cls() if handler_cls else None
if not handler:
raise ValueError(
f"当前检查的check_stat为：{self.check_stat}，优先级为{self.priority}，暂无处理该属性的逻辑模块！"
)
return self.spawn_result(
handler.handler(int(self.check_target), found_char_dict, game_state, sim_instance)
)
================================================
FILE: zsim/sim_progress/Preload/APLModule/SubConditionUnit/__init__.py
================================================
from .BaseSubConditionUnit import BaseSubConditionUnit # noqa: I001
from .ActionSubUnit import ActionSubUnit
from .AttributeSubUnit import AttributeSubUnit
from .BuffSubUnit import BuffSubUnit
from .SpecialSubUnit import SpecialSubUnit
from .StatusSubUnit import StatusSubUnit
__all__ = [
"BaseSubConditionUnit",
"StatusSubUnit",
"AttributeSubUnit",
"BuffSubUnit",
"ActionSubUnit",
"SpecialSubUnit",
]
================================================
FILE: zsim/sim_progress/Preload/APLModule/__init__.py
================================================
from .APLClass import APLClass
from .APLManager import APLManager
from .APLOperator import APLOperator
from .APLParser import APLParser
__all__ = [
"APLOperator",
"APLParser",
"APLClass",
"APLManager",
]
================================================
FILE: zsim/sim_progress/Preload/PreloadClass.py
================================================
from typing import TYPE_CHECKING, Iterable
from .PreloadDataClass import PreloadData
from .PreloadStrategy import SwapCancelStrategy
if TYPE_CHECKING:
from zsim.sim_progress.Character.skill_class import Skill
from zsim.simulator.dataclasses import LoadData
from zsim.simulator.simulator_class import Simulator
class PreloadClass:
def __init__(
self,
skills: Iterable["Skill"],
*,
load_data: "LoadData",
apl_path: str | None = None,
sim_instance: "Simulator | None" = None,
**kwargs,
):
self.preload_data: "PreloadData" = PreloadData(
skills, load_data=load_data, sim_instance=sim_instance
)
self.apl_path = apl_path
self.strategy = SwapCancelStrategy(self.preload_data, apl_path)
def do_preload(self, tick, enemy, name_box, char_data):
if self.preload_data.name_box is None:
self.preload_data.name_box = name_box
if self.preload_data.char_data is None:
self.preload_data.char_data = char_data
self.strategy.generate_actions(enemy, tick)
def reset_myself(self, namebox):
self.preload_data.reset_myself(namebox)
================================================
FILE: zsim/sim_progress/Preload/PreloadDataClass.py
================================================
from typing import TYPE_CHECKING, Iterable
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from .SkillsQueue import SkillNode
if TYPE_CHECKING:
from zsim.sim_progress.Character.skill_class import Skill
from zsim.sim_progress.data_struct import EnemyAttackEventManager, NodeStack, QuickAssistSystem
from zsim.sim_progress.Load.loading_mission import LoadingMission
from zsim.simulator.dataclasses import CharacterData, LoadData
from zsim.simulator.simulator_class import Simulator
class PreloadData:
"""循环于Preload阶段内部的数据"""
def __init__(
self,
skills: Iterable["Skill"],
sim_instance: "Simulator | None",
load_data: "LoadData",
**kwargs,
):
self.sim_instance: "Simulator | None" = sim_instance
self.preload_action: list[SkillNode] = [] # 最终return返回给外部申请的数据结构
self.skills: Iterable["Skill"] = (
skills # 用于创建SkillNode，是SkillNode构造函数的必要参数。
)
from zsim.sim_progress.data_struct import NodeStack
self.personal_node_stack: dict[
int, "NodeStack[SkillNode]"
] = {} # 个人的技能栈（包括主动生成的和被动生成的）
self.personal_active_generation_node_stack: dict[
int, "NodeStack[SkillNode]"
] = {} # 个人的主动生成的技能栈
self.current_node_stack: "NodeStack[SkillNode]" = NodeStack(
length=5
) # Preload阶段的总技能栈
self.latest_active_generation_node: SkillNode | None = (
None # 最近一次主动生成的skillnode，#TODO：可能是无用参数！
)
self.preload_action_list_before_confirm: list[
tuple[str, bool, int]
] = [] # 当前tick需要执行preload的SkillTag列表，列表中的元素是(skill_tag, active_generation)，其中，active_generation指的是动作是否是主动生成。
self.name_box: list[str] | None = None
self.char_data: "CharacterData | None" = None
self.load_data: "LoadData" = load_data
self.load_mission_dict: dict[str, "LoadingMission"] = load_data.load_mission_dict
self.quick_assist_system: "QuickAssistSystem | None" = None
self.atk_manager: "EnemyAttackEventManager | None" = None
@property
def operating_now(self) -> int | None:
"""返回正在操作的角色"""
if self.latest_active_generation_node is None:
return None
_cid = int(self.latest_active_generation_node.skill_tag.split("_")[0])
return _cid
def push_node_in_swap_cancel(self, node: SkillNode, tick: int):
"""合轴模式中的内部数据更新函数。将构造好的SkillNode加入preload_action中，同时更新Preload板块的内部数据。"""
assert self.sim_instance is not None
self.check_myself_before_push_node()
self.preload_action.append(node)
char_cid = int(node.skill_tag.split("_")[0])
self.current_node_stack.push(node)
if char_cid not in self.personal_node_stack:
from zsim.sim_progress.data_struct import NodeStack
self.personal_node_stack[char_cid] = NodeStack(length=3)
self.personal_active_generation_node_stack[char_cid] = NodeStack(length=3)
if not self.personal_node_stack[char_cid].last_node_is_end(tick):
"""若检测到当前stack中的最新node还未结束，但是SwapCancel还是放行了，那么就说明可能发生了node的顶替，
此时应该排除是附加伤害的可能性，因为附加伤害是可以被swapcancel轻易放行的，但是并不具备打断的效果。"""
if not (
node.skill.labels is not None
and "additional_damage" in node.skill.labels # 技能拥有附加标签
):
self.force_change_action(node)
if self.personal_node_stack[char_cid].is_empty():
"""检测角色的第一个动作抛出。"""
self.sim_instance.listener_manager.broadcast_event(event=node, signal=LBS.ENTER_BATTLE)
self.personal_node_stack[char_cid].push(node)
if node.active_generation:
self.latest_active_generation_node = node
self.personal_active_generation_node_stack[char_cid].push(node)
if self.quick_assist_system is None:
assert self.char_data is not None
from zsim.sim_progress.data_struct import QuickAssistSystem
self.quick_assist_system = QuickAssistSystem(
self.char_data.char_obj_list, sim_instance=self.sim_instance
)
self.quick_assist_system.update(tick, node, self.load_data.all_name_order_box)
if self.atk_manager is not None and self.atk_manager.attacking:
self.atk_manager.answered_action.append(node)
from zsim.sim_progress.Preload.APLModule.ActionReplaceManager import ActionReplaceManager
action_replace_manager: "ActionReplaceManager" = (
self.sim_instance.preload.strategy.apl_engine.apl.action_replace_manager
)
if action_replace_manager is not None:
action_replace_manager.parry_aid_strategy.update_myself(skill_node=node, tick=tick)
def check_myself_before_push_node(self):
"""Confirm阶段自检"""
_active_generation_node_list = []
for _node in self.preload_action:
if _node.active_generation:
_active_generation_node_list.append(_node)
if len(_active_generation_node_list) > 1:
raise ValueError(
f"在一个Tick中检测到了多个主动技能！共有：{_active_generation_node_list}"
)
def get_on_field_node(self, tick: int) -> SkillNode | None:
"""获取当前的前台技能"""
return self.current_node_stack.get_on_field_node(tick)
def chek_myself_before_start_preload(self, enemy, tick):
"""Preload阶段自检"""
if self.preload_action:
print(f"尚未被Load阶段处理的技能：{self.preload_action}")
enemy.stun_judge(tick)
def external_add_skill(self, skill_tuple: tuple[str, bool, int]):
"""外部Buff向下一个Tick添加技能的接口，通常用于协同攻击"""
skill_tag, active_generation, apl_priority = skill_tuple
self.preload_action_list_before_confirm.append(skill_tuple)
def reset_myself(self, name_box):
"""重置preload_data"""
self.preload_action = [] # 最终return返回给外部申请的数据结构
for cid, stack in self.personal_node_stack.items():
stack.reset()
self.current_node_stack.reset()
self.latest_active_generation_node = None
self.preload_action_list_before_confirm = []
self.name_box = name_box
def force_change_action(self, skill_node: SkillNode):
"""强制更新动作，用于技能强制顶替、被打断或是类似场合"""
char_cid = int(skill_node.skill_tag.strip().split("_")[0])
node_be_changed: "SkillNode | None" = self.personal_node_stack[char_cid].peek()
if node_be_changed is None:
raise ValueError
if node_be_changed.end_tick <= skill_node.preload_tick:
raise ValueError(
f"尝试用{skill_node.skill_tag}来强制替换{node_be_changed.skill_tag}，但是后者已经于{node_be_changed.end_tick}结束，这种情况不用调用强制替换方法。请检查调用逻辑。"
)
self.delete_mission_in_preload_data(node_be_changed)
if node_be_changed.skill.do_immediately and "dodge" not in node_be_changed.skill_tag:
raise ValueError(
f"{skill_node.skill_tag}正在尝试顶替一个最高优先级的技能：{node_be_changed.skill_tag}"
)
def delete_mission_in_preload_data(self, node_be_changed: "SkillNode"):
"""在PreloadData中强制干涉Load阶段，并且执行特定任务的删除。"""
mission_key_to_remove: list[str] = []
for mission_key, mission in self.load_mission_dict.items():
from zsim.sim_progress.Load import LoadingMission
if not isinstance(mission, LoadingMission):
continue
if mission.mission_tag == node_be_changed.skill_tag:
mission.mission_end()
mission_key_to_remove.append(mission_key)
for key in mission_key_to_remove:
self.load_mission_dict.pop(key)
def char_occupied_check(self, char_cid: int, tick: int):
"""检查角色当前是否存在动作（无论主动、被动）"""
char_stack = self.personal_node_stack.get(char_cid, None)
if char_stack is None:
return True
latest_node = char_stack.get_effective_node()
if latest_node is None:
return True
if latest_node.end_tick > tick:
return True
return False
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/APLEngine.py
================================================
from typing import TYPE_CHECKING
from zsim.define import APL_PATH, APL_THOUGHT_CHECK
from zsim.define import APL_THOUGHT_CHECK_WINDOW as ATCW
from ..APLModule import APLManager
from ..SkillsQueue import SkillNode, spawn_node
from .BasePreloadEngine import BasePreloadEngine
if TYPE_CHECKING:
from ..PreloadDataClass import PreloadData
class APLEngine(BasePreloadEngine):
"""用于调动APL模块的Preload引擎"""
def __init__(self, data: "PreloadData", apl_path: str | None = None):
super().__init__(data)
self.preload_data = data
self.sim_instance = self.preload_data.sim_instance
if self.sim_instance is None:
raise ValueError("APLEngine requires a sim_instance to be provided.")
self.apl_manager = APLManager(sim_instance=self.sim_instance)
if apl_path is None:
apl_path = APL_PATH
elif not apl_path.endswith(".txt") or not apl_path.endswith(".toml"):
# 如果提供的是APL名称而不是完整路径
found_path = self.apl_manager.get_apl_path(apl_path)
if found_path:
apl_path = found_path
self.apl = self.apl_manager.load_apl(apl_path, mode=0, preload_data=self.preload_data)
self.latest_node: SkillNode | None = None
self._apl_want: tuple | None = None # APL引擎的想法
@property
def apl_want(self) -> tuple | None:
return self._apl_want
@apl_want.setter
def apl_want(self, value: tuple | None) -> None:
skill_tag, apl_priority, apl_unit = value if value else (None, None, None)
if APL_THOUGHT_CHECK:
tick = self.sim_instance.tick
if tick in range(ATCW[0], ATCW[1]):
if value != self.apl_want:
print(
f"{tick}tick：APL引擎的想法变化，{self.apl_want[0] if self.apl_want else None} → {skill_tag}，来自于优先级 {apl_priority} 的单元，详细内容：{apl_unit.whole_line}"
) if self.apl_want is not None else print(
f"{tick}tick：APL引擎产生了第一个想法：{skill_tag}"
)
self._apl_want = value
def run_myself(self, tick) -> SkillNode | None:
"""APL模块运行的最终结果：技能名、最终通过的APL代码优先级"""
skill_tag, apl_priority, apl_unit = self.apl.execute(tick, mode=0)
self.apl_want = (skill_tag, apl_priority, apl_unit)
if skill_tag == "wait":
return None
node = spawn_node(
skill_tag,
tick,
self.data.skills,
active_generation=True,
apl_priority=apl_priority,
apl_unit=apl_unit,
)
return node
def reset_myself(self):
"""APL模块暂时没有任何需要Reset的地方！"""
self.latest_node = None
def get_available_apls(self) -> list[str]:
"""获取所有可用的APL文件列表"""
return self.apl_manager.list_available_apls()
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/AttackAnswerEngine.py
================================================
from typing import TYPE_CHECKING
from .BasePreloadEngine import BasePreloadEngine
if TYPE_CHECKING:
from zsim.sim_progress.Character import Character
from zsim.sim_progress.Enemy import Enemy
from zsim.sim_progress.Enemy.EnemyAttack.EnemyAttackClass import EnemyAttackAction
from zsim.simulator.simulator_class import Simulator
from ..PreloadDataClass import PreloadData
class AttackResponseEngine(BasePreloadEngine):
"""进攻响应引擎，主要负责敌人进攻动作抛出，以及角色动作响应相关的内容；"""
def __init__(self, data: "PreloadData", sim_instance: "Simulator | None" = None):
assert sim_instance is not None
super().__init__(data)
self.data: "PreloadData" = data
self.game_state = None
self.found_char_dict: dict[int, "Character"] = {}
self.enemy: "Enemy | None" = None
self.sim_instance: "Simulator" = sim_instance
def run_myself(self, tick: int, *args, **kwargs) -> bool:
if self.data.atk_manager is None:
from zsim.sim_progress.data_struct import EnemyAttackEventManager
self.data.atk_manager = EnemyAttackEventManager(
enemy_instance=self.sim_instance.schedule_data.enemy
)
self.data.atk_manager.end_check(tick=tick)
enemy_attack_action: "EnemyAttackAction | None" = self.try_spawn_enemy_attack()
if enemy_attack_action is not None:
# 将进攻信号发送给PreloadData。
self.data.atk_manager.event_start(
action=enemy_attack_action, start_tick=self.sim_instance.tick
)
"""每次运行，都要让atk_manager自检一次，以更新状态。"""
self.data.atk_manager.check_myself(tick=tick)
return True
def try_spawn_enemy_attack(self) -> "EnemyAttackAction | None":
"""调用Enemy对象下的进攻模组，并且生成一次攻击，同时打包成事件存入本地"""
if self.sim_instance is None and self.data.sim_instance is not None:
self.sim_instance = self.data.sim_instance
if self.enemy is None:
self.enemy = self.sim_instance.schedule_data.enemy
if (
not self.enemy.attack_method.active
or self.enemy.dynamic.stun
or (
self.data.atk_manager is not None
and self.data.atk_manager.interruption_recovery_check(tick=self.sim_instance.tick)
)
):
return None
if self.enemy.attack_method.random_attack:
enemy_attack_action = self.enemy.attack_method.probablity_driven_action_selection(
current_tick=self.sim_instance.tick
)
else:
enemy_attack_action = self.enemy.attack_method.time_anchored_action_selection(
current_tick=self.sim_instance.tick
)
return enemy_attack_action
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/BasePreloadEngine.py
================================================
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from .. import PreloadData
class BasePreloadEngine(ABC):
@abstractmethod
def __init__(self, data: "PreloadData"):
self.data = data
self.active_signal = False # 用于记录当前引擎在当前tick是否运行过。
@abstractmethod
def run_myself(self, *args, **kwargs) -> Any:
return False
__all__ = ["BasePreloadEngine"]
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/ConfirmEngine.py
================================================
from typing import TYPE_CHECKING
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from zsim.sim_progress.Report import report_to_log
from ..PreloadEngine import BasePreloadEngine
from ..SkillsQueue import SkillNode, spawn_node
if TYPE_CHECKING:
from zsim.sim_progress.Character import Character
from zsim.sim_progress.Preload.PreloadDataClass import PreloadData
class ConfirmEngine(BasePreloadEngine):
def __init__(self, data: "PreloadData"):
"""
这个引擎的主要功能有：
1、将各环节产生的需要进行Preload的skill_tag，构造成SkillNode，
2、可行性验证
3、内部数据交互、更新
4、外部数据交互、更新
"""
super().__init__(data)
self.external_update_signal = False
self.external_add_skill_list = []
self.validators = [self._validate_timing]
self.name_box_first_change = True # 首次更改name_box的标志
def run_myself(self, tick: int, **kwargs) -> bool:
"""依次执行 Node构造、验证、内外部数据交互"""
apl_skill_node: SkillNode | None = kwargs.get("apl_skill_node", None)
apl_skill_tag = kwargs.get("apl_skill_tag", None)
if apl_skill_node is None and apl_skill_tag != "wait":
raise ValueError("ConfirmEngine 并未获取到 APL Skill Node，请检查输入")
for i in range(len(self.data.preload_action_list_before_confirm)):
tuples = self.data.preload_action_list_before_confirm.pop()
# 1、创建node
node = self.spawn_node_from_tag(tick, tuples, template_node_from_apl=apl_skill_node)
# 2、可行性验证
if self.validate_node_execution(node, tick):
# 3、内部数据交互
self.data.push_node_in_swap_cancel(node, tick)
report_to_log(f"[PRELOAD]:In tick: {tick}, {node.skill_tag} has been preloaded")
# 4、外部数据交互
self.update_external_data(node, tick)
# print(f'{node.skill_tag}通过了可行性验证，该主动动作来自于优先级为{node.apl_priority}的APL代码')
# if any(
# [_subtags in node.skill_tag for _subtags in ["knock_back", "parry"]]
# ):
# print(
# f"{node.skill_tag}被ConfirmEngine接收，它将从{node.preload_tick}开始，于{node.end_tick}结束。"
# )
else:
pass
return True
def spawn_node_from_tag(
self,
tick: int,
tuples: tuple[str, bool, int],
template_node_from_apl: SkillNode | None = None,
):
"""通过skill_tag构造Node"""
skill_tag = tuples[0]
active_generation = tuples[1] if tuples[1] else False
if template_node_from_apl and skill_tag == template_node_from_apl.skill_tag:
apl_unit = template_node_from_apl.apl_unit
else:
apl_unit = None
node = spawn_node(
skill_tag,
tick,
self.data.skills,
active_generation=active_generation,
apl_priority=tuples[2],
apl_unit=apl_unit,
)
return node
def update_external_data(self, node: SkillNode, tick: int):
"""与外部数据交互，主要是和char进行交互。"""
if self.data.char_data:
for char in self.data.char_data.char_obj_list:
char.update_sp_and_decibel(node)
char.special_resources(node, tick=tick)
char.dynamic.lasting_node.update_node(node, tick)
# 切人逻辑
name_box = self.data.name_box
if (
isinstance(name_box, list)
and all(isinstance(name, str) for name in name_box)
and node.active_generation
and self.data.char_data is not None
):
self.switch_char(node, self.data.char_data)
if self.data.sim_instance:
self.data.sim_instance.decibel_manager.update(skill_node=node)
def switch_char(self, this_node: SkillNode, char_data) -> None:
name_box = self.data.name_box
if name_box is None:
return
old_name_box = name_box.copy()
name_index = name_box.index(this_node.char_name)
# 更改前台角色（切人逻辑）
if name_index == 1:
name_switch = name_box.pop(0)
name_box.append(name_switch)
elif name_index == 2:
name_switch = name_box.pop(0)
name_box.append(name_switch)
name_switch = name_box.pop(0)
name_box.append(name_switch)
for char in char_data.char_obj_list:
char: "Character"
if name_box[0] == char.NAME:
if name_box[0] != old_name_box[0]:
"""在更新name_box的时候，将切人事件对所有监听器进行广播。"""
if self.data.sim_instance:
self.data.sim_instance.listener_manager.broadcast_event(
event=char, signal=LBS.SWITCHING_IN, skill_node=this_node
)
char.dynamic.on_field = True
else:
# 首次切人逻辑
if self.name_box_first_change:
if self.data.sim_instance:
self.data.sim_instance.listener_manager.broadcast_event(
event=char, signal=LBS.SWITCHING_IN, skill_node=this_node
)
char.dynamic.on_field = True
self.name_box_first_change = False
else:
char.dynamic.on_field = False
def validate_node_execution(self, node: SkillNode, tick: int) -> bool:
"""集中验证节点可执行性"""
# watchdog.watch_reverse_order(node, self.data.personal_node_stack.peek())
result = all(validator(node, tick) for validator in self.validators)
return result
@staticmethod
def _validate_timing(node: SkillNode, tick: int) -> bool:
"""检验preload_tick的封装是否有问题，"""
results = node.preload_tick <= tick
if not results:
print(
f"Preload Tick的可行性验证未通过！应在{node.preload_tick}tick preload的{node.skill_tag}技能过早的在confirm引擎中出现！"
)
return node.preload_tick <= tick
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/ForceAddEngine.py
================================================
from typing import TYPE_CHECKING
from ..APLModule.APLJudgeTools import get_game_state
from ..PreloadEngine import BasePreloadEngine
from ..SkillsQueue import SkillNode
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class ForceAddEngine(BasePreloadEngine):
"""该引擎的主要作用是：在技能结束时，检索它们的后置技能，并且执行添加"""
def __init__(self, data):
super().__init__(data)
self.game_state = None
self.found_char_dict = {}
def run_myself(self, tick: int) -> bool:
"""当每个node结束时，都应该调用这个函数来判断强制添加。"""
self.active_signal = False
if not self.data.personal_node_stack:
return True
for _, stack in self.data.personal_node_stack.items():
node: SkillNode | None
node = stack.peek()
if node is None:
continue
if node.end_tick > tick:
"""如果当前node并未结束，则不符合“node”结束的条件，则应该直接跳过。"""
continue
follow_up: list[str] = node.skill.follow_up
if not follow_up:
continue
conditions_unit: list = node.skill.force_add_condition_APL
should_force_add, index = self.prcoess_force_add_apl(
conditions_unit,
skill_tag=node.skill_tag,
tick=tick,
sim_instance=self.data.sim_instance,
)
if should_force_add:
# print(f'强制添加判定通过！该强制添加来自于{node.skill_tag}，将要添加：{follow_up[index]}')
self.check_char(follow_up, index, node) # 检验数据的正确性
self.data.preload_action_list_before_confirm.append((follow_up[index], False, 0))
self.active_signal = True
return True
def check_char(self, follow_up: list, index: int, node: SkillNode):
"""
该函数的作用：确保：B角色技能在强制预载时，并没有动作存在即可。
如果程序流程合理，这个函数是不会被执行的。
"""
follow_up_skill_CID = int(follow_up[index][:4])
follow_up_skill_add_tick = node.end_tick
if self.data.personal_node_stack is None:
return
followed_char_stack = self.data.personal_node_stack.get(follow_up_skill_CID, None)
if followed_char_stack is not None:
latest_node: SkillNode | None = followed_char_stack.peek()
if latest_node is not None and node.end_tick < latest_node.end_tick:
raise ValueError(
f"出现了不应该出现的情况！技能{follow_up[index]}理应在{node.skill_tag}之后、于{follow_up_skill_add_tick}执行，但是此时角色{follow_up_skill_CID}尚有动作存在。"
)
def prcoess_force_add_apl(
self, conditions_unit, sim_instance: "Simulator | None", **kwargs
) -> tuple[bool, int]:
"""强制添加动作的前置判定，有APL模块则运行模块，无APL模块则直接通过。"""
should_force_add = True
index = 0
tick = kwargs.get("tick", None)
if conditions_unit and self.game_state is None:
if sim_instance:
self.game_state = get_game_state(sim_instance=sim_instance)
if conditions_unit:
"""存在条件类APL判定"""
for unit in conditions_unit:
_apl_result, result_box = unit.check_all_sub_units(
self.found_char_dict,
self.game_state,
tick=tick,
sim_instance=sim_instance,
)
if not _apl_result:
"""当apl单元的自运行结果为False时，意味着该条APL的条件中存在着不满足的项，所以应该continue，赶紧去检查下个Box"""
should_force_add = False
index += 1
else:
should_force_add = True
return should_force_add, index
else:
"""
for循环执行完毕后，还是没有return，那么就意味着，当前所有的APL单元的自运行都没通过，
也就是说当前该动作组中的所有衔接动作都不满足自动衔接的条件，
此时，返回False， index（这里的index其实已经无所谓了）
"""
return should_force_add, index
else:
return should_force_add, index
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/SwapCancelValidateEngine.py
================================================
import math
from zsim.define import (
SWAP_CANCEL_DEBUG_TARGET_SKILL,
SWAP_CANCEL_MODE_DEBUG,
)
from zsim.define import (
SWAP_CANCEL_MODE_COMPLETION_COEFFICIENT as SCK,
)
from zsim.define import (
SWAP_CANCEL_MODE_LAG_TIME as SCLT,
)
from ..SkillsQueue import SkillNode
from .BasePreloadEngine import BasePreloadEngine
# EXPLAIN：关于SCK和LT的作用：
"""
以上两个系数分别是：
①合轴操作完成度系数 SWAP_CANCEL_MODE_COMPLETION_COEFFICIENT （程序中通常引用为SCK）
②操作滞后系数 SWAP_CANCEL_MODE_LAG_TIME （程序中通常引用为SCLT），它们共同用于模拟玩家的合轴操作。
因为不可能任意操作都具有完美的完成度（在第2帧就完美切人+下一招出手），
人体机能限制、注意力不集中、可能存在的操作习惯以及其他因素，都会导致合轴操作的延后实施，
所以，这里通过设置一个系数来模拟玩家的操作滞后程度，在计算时，我会取用skill_node的时长（skill.ticks)，并且乘以SCK，
所计算出的结果与SCLT参数相比较，取较小值作为最终的滞后时间（防止较长的技能滞后严重，导致模拟失真）。
后续的升级方向：
在引入随机数生成器后，可以进一步基于两个参数的基本值，对这两个参数进行随机处理，从而真正模拟玩家在操作端的浮动。
"""
class SwapCancelValidateEngine(BasePreloadEngine):
"""该引擎的作用是：判断当前传入的APL运行结果是否满足合轴的需求"""
def __init__(self, data):
super().__init__(data)
self.validators = [
self._validate_char_avaliable,
self._validate_char_task_conflict,
self._validate_swap_tick,
self._validate_qte_activation,
self._validate_wait_event,
self._validate_swap_state_check,
self._validate_swap_strategy_check,
]
self.__report_tag = None
@property
def external_update_signal(self):
return True if self.data.preload_action_list_before_confirm else False
def run_myself(
self,
skill_tag: str,
tick: int,
apl_priority: int = 0,
apl_skill_node: SkillNode | None = None,
**kwargs,
) -> bool:
"""合轴可行性分析基本分为以下几个步骤：
1、当前涉及角色是否有空
2、合轴时间是否符合
3、确认合轴后，将skill_tag和主动参数 打包成tuple"""
self.active_signal = False
"""若当前APL动作为等待，那么直接返回False，不做任何操作。"""
if self._validate_wait_event(apl_skill_tag=skill_tag):
self._swap_cancel_debug_print(mode=0, skill_tag=skill_tag)
return False
"""检测对应角色是否有空——当前tick是否存在未完成动作"""
if not self._validate_char_avaliable(
skill_tag=skill_tag, tick=tick, apl_skill_node=apl_skill_node
):
self._swap_cancel_debug_print(mode=1, skill_tag=skill_tag)
return False
"""检测当前tick的APL输出是否与角色自身的任务冲突——动作的顶替判定"""
if not self._validate_char_task_conflict(
skill_tag=skill_tag, apl_skill_node=apl_skill_node, tick=tick
):
self._swap_cancel_debug_print(mode=2, skill_tag=skill_tag)
return False
"""QTE状态过滤器——QTE阶段不支持任何合轴"""
if self._validate_qte_activation(tick=tick, skill_node=apl_skill_node):
return False
"""检测当前tick的角色状态是否支持合轴——切人CD检测、高优先级动作判定"""
if not self._validate_swap_state_check(
tick=tick, skill_tag=skill_tag, apl_skill_node=apl_skill_node
):
self._swap_cancel_debug_print(mode=3, skill_tag=skill_tag)
return False
"""检测当前的tick是否满足合轴操作的需求"""
if not self._validate_swap_tick(skill_tag=skill_tag, tick=tick):
self._swap_cancel_debug_print(mode=4, skill_tag=skill_tag)
return False
"""检测当前的前台动作是否允许进行合轴——合轴策略过滤"""
if not self._validate_swap_strategy_check(tick=tick, skill_tag=skill_tag):
return False
self.data.preload_action_list_before_confirm.append((skill_tag, True, apl_priority))
self.active_signal = True
return True
def _validate_char_avaliable(
self, skill_tag: str, apl_skill_node: SkillNode | None, tick: int
) -> bool:
"""角色是否可以获取的判定"""
cid = int(skill_tag.split("_")[0])
char_stack = self.data.personal_node_stack.get(cid, None)
if char_stack is None:
"""角色的动作栈都尚未创建，说明角色当前没有任何动作，角色有空。"""
return True
"""获取上一个非附加伤害的技能Node"""
"""
在v0.3.4的开发过程中，我发现在一些极端情况下，当角色的personal_node_stack被数量较多的附加伤害技能填充时，
会发生一个无法有效读取角色当前正在进行的技能的问题，
这个问题将直接导致 合轴条件检测机制 会认为 “当前角色有空”而直接放行，从而导致“自己合轴自己”的情况发生。
比如爱丽丝6画会在三蓄发动时生效，队友的一些Hit会高频触发这个6画的附加伤害，
大量的"1401_Cinema_6"的skill_node涌入personal_node_stack，并且迅速超过上限，于是本该正在进行的技能"1401_SNA_3"因溢出而被pop移除了。
这样一来，get_effective_node()发现当前node_stack中全部都是附加伤害技能，就直接返回None，导致函数直接放行，
虽然整个SwapCancelValidateEngine内置多个校验器，但是关于角色是否“有空”的校验只有这一个，
这导致一旦本函数放行，后续的校验器将完全默认“角色有空”，最终导致某些场景下的错误判断。
更新后，我在get_effective_node()的返回结果为None的情况下，进一步检查角色的dynamic.lasting_node.node是否为None。
如果dynamic.lasting_node.node也为None，那么说明角色当前确实没有任何动作，角色才是真正“有空的”。
"""
try_get_char_latest_node = char_stack.get_effective_node()
if try_get_char_latest_node is None:
from zsim.sim_progress.Character.character import Character
char = self.data.char_data.find_char_obj(CID=cid)
assert isinstance(char, Character)
if char.dynamic.lasting_node.node is not None:
char_latest_node = char.dynamic.lasting_node.node
else:
char_latest_node = None
else:
char_latest_node = try_get_char_latest_node
# char_latest_active_node = char_stack.get_on_field_node(tick)
# if char_latest_active_node is not None:
# print(char_latest_node.skill_tag, char_latest_active_node.skill_tag)
if char_latest_node is None:
"""角色栈已经创建但是上一个动作为空，说明本动作是角色的第一个动作，角色有空。"""
return True
# print([_stacknode.skill_tag for _stacknode in char_stack.stack])
# print(f'APL：{apl_skill_node.skill_tag, apl_skill_node.apl_priority}， 上个技能：{char_latest_node.skill_tag, char_latest_node.apl_priority, char_latest_node.end_tick}')
"""角色当前有一个正在发生的Node"""
if char_latest_node.end_tick > tick:
"""如果该node是闪避，则直接放行——闪避是可以被自己的技能合轴、顶替的。"""
if "dodge" in char_latest_node.skill_tag:
# print(
# f"{apl_skill_node.char_name}的技能{apl_skill_node.skill_tag}企图取消自己的闪避技能！"
# ) if SWAP_CANCEL_MODE_DEBUG else None
return True
elif "parry" in char_latest_node.skill_tag and "knock_back_cause_parry" in skill_tag:
"""对于衔接于招架之后的击退，要立即放行"""
return True
"""正在进行的技能并非立即执行类型，而新的技能是立即执行类型，则放行"""
if (
apl_skill_node is not None
and apl_skill_node.skill.do_immediately
and not char_latest_node.skill.do_immediately
):
return True
else:
return False
else:
"""角色上一个动作已经结束，说明角色有空。"""
return True
@staticmethod
def spawn_lag_time(node: SkillNode) -> int:
"""
生成滞后时间，关于函数中两个参数SCK和SCLT的含义，请参考本文件开头的注释。
这里返回的lag_time是经过向上取整的。
"""
lag_time = math.ceil(min(node.skill.ticks * SCK, SCLT))
return lag_time
def _validate_swap_tick(self, skill_tag: str, tick: int, **kwargs):
"""针对当前技能的合轴时间的检测"""
current_node_on_field = self.data.get_on_field_node(tick)
if current_node_on_field is None:
return True
# 放行所有的附加伤害——附加伤害通常都没有动作，所以无需合轴
if (
current_node_on_field.skill.labels is not None
and "additional_damage" in current_node_on_field.skill.labels
):
return True
# 放行特别豁免清单中的技能，比如被击退等特殊动作；
if any([_sub_tag in skill_tag for _sub_tag in ["knock_back"]]):
return True
swap_lag_tick = self.spawn_lag_time(current_node_on_field)
if (
swap_lag_tick
+ current_node_on_field.skill.swap_cancel_ticks
+ current_node_on_field.preload_tick
> tick
):
return False
else:
if SWAP_CANCEL_MODE_DEBUG and SWAP_CANCEL_DEBUG_TARGET_SKILL:
if SWAP_CANCEL_DEBUG_TARGET_SKILL == skill_tag:
print(
f"监听的技能{skill_tag}满足合轴时间要求！合轴放行！上一个技能{current_node_on_field.skill_tag}因本次合轴而提前结束。"
f"本次合轴延迟时间为{swap_lag_tick + current_node_on_field.skill.swap_cancel_ticks}ticks，被合轴技能时间为{current_node_on_field.skill.ticks}ticks。"
)
return True
def _validate_qte_activation(self, tick: int, skill_node: SkillNode | None) -> bool:
"""针对当前技能的QTE是否处于激活状态的检测，当检查到有角色正在释放QTE时，返回True"""
# enemy = self.data.sim_instance.schedule_data.enemy
# if enemy.qte_manager.qte_data.single_qte is not None:
# if skill_node.skill.trigger_buff_level != 5:
# return True
for _cid, stack in self.data.personal_node_stack.items():
if stack.peek() is None:
continue
node_now = stack.peek()
if node_now is not None and node_now.end_tick > tick:
if "QTE" in node_now.skill_tag:
# FIXME: 由于伊芙琳的QTE是可以进行合轴的，这里一定会遇到Bug。
return True
continue
else:
return False
def _validate_wait_event(self, apl_skill_tag: str | None = None) -> bool:
"""用于检测传入的apl动作是否为wait。"""
if apl_skill_tag == "wait":
return True
else:
return False
def _validate_char_task_conflict(
self, skill_tag: str, apl_skill_node: SkillNode | None, tick: int
) -> bool:
"""
针对角色自身的任务冲突的检测——尽管角色当前tick有空
但并不意味着apl抛出的动作就可以直接执行。
APL抛出的动作还需要和角色自身的任务进行冲突检测，相互竞争和覆盖。
"""
if apl_skill_node is None:
return True
cid = int(skill_tag.split("_")[0])
for _tuples in self.data.preload_action_list_before_confirm:
_tuples: tuple[str, bool, int]
"""
preload_data中，preload_action_list_before_confirm是一个列表，
其中记录了当前tick要被抛出的动作，其中，每个元素是一个元组，
元组的第一个元素是技能的tag，第二个元素是技能的主动类型，第三个元素是APL的优先级。
对于当前函数来说，APL抛出的动作apl_skill_node尚未进入preload_action_list_before_confirm列表，
此时该列表中的所有技能都来自于ForceAddEngine强行添加。
"""
_tag = _tuples[0]
if cid == int(_tag.split("_")[0]):
"""如果角色在当前tick有forceadd的任务，并且APL抛出的动作并非do_immediately，则返回False"""
if not apl_skill_node.skill.do_immediately:
return False
for obj in self.data.skills:
if not obj.CID == cid:
continue
if obj.get_skill_info(skill_tag=_tag, attr_info="do_immediately"):
"""如果当前tick被force_add添加的skill_tag本来就是do_immediately类型，那么就没法抢队了"""
return False
else:
"""附加伤害additional_damage（类似于“白雷”）由于不需要占用角色，所以可以免于被挤掉的命运"""
skill_info = obj.get_skill_info(skill_tag=_tag, attr_info="labels")
if skill_info is None:
skill_info = {}
if (
not isinstance(skill_info, dict)
or "additional_damage" not in skill_info
):
"""但若当前tick被force_add 添加的skill_tag只是个普通技能，那么就要执行顶替。"""
(
print(f"即将添加的衔接技能：{_tuples}被{skill_tag}顶替！")
if SWAP_CANCEL_MODE_DEBUG
else None
)
self.data.preload_action_list_before_confirm.remove(_tuples)
return True
break
else:
raise ValueError(f"没找到{cid}对应的角色！")
else:
continue
else:
return True
def _validate_swap_state_check(
self, tick: int, skill_tag: str, apl_skill_node: SkillNode | None
):
"""检查角色当前的状态是否允许当前技能进行合轴"""
cid = int(skill_tag.split("_")[0])
node_on_field: SkillNode | None = self.data.get_on_field_node(tick)
char_node_stack = self.data.personal_node_stack.get(cid, None)
char_latest_node: SkillNode | None = char_node_stack.peek() if char_node_stack else None
char_change_cd: bool
last_actively_generated_node: SkillNode | None = self.data.latest_active_generation_node
if node_on_field and not node_on_field.active_generation:
"""
由于get_on_field_node函数只会尽量返回台前的主动技能，
而当场上仅存在一个被动技能时，该技能也会被函数获取并且返回。
这里需要检测返回结果的主动生成状态，若为False，则说明当前前台技能是被动技能，
此时，node_on_field等同于None
"""
node_on_field = None
if char_latest_node is None:
char_change_cd = True
else:
tick_delta = tick - char_latest_node.end_tick
char_change_cd = tick_delta >= 60
"""当前台存在一个高优先级技能时，合轴操作都是不可用的"""
if (
node_on_field is not None
and node_on_field.skill.do_immediately
and "dodge" not in node_on_field.skill_tag
):
return False
"""第一个主动动作时，直接放行"""
if last_actively_generated_node is None:
return True
"""当前台不存在技能或是前台技能并非高优先级时，那么可以进行合轴的进一步判定"""
if str(cid) not in last_actively_generated_node.skill_tag:
"""当动作涉及切人时，需要进行切人CD的检测"""
if char_change_cd:
"""当前角色的切人CD已经冷却完毕，则直接放行。"""
return True
else:
if apl_skill_node is None:
return False
if (
any([_sub_tag in skill_tag for _sub_tag in ["QTE", "Aid", "knock_back"]])
or apl_skill_node.skill.do_immediately
):
"""如果是支援类和连携技这种无视切人CD的技能，那么此时角色可以切出"""
return True
else:
return False
else:
"""当动作不涉及切人时，直接放行"""
return True
def _validate_swap_strategy_check(self, tick: int, skill_tag: str):
"""该函数用于检测当前技能的合轴策略是否允许合轴——在场的主动动作是否允许合轴。"""
cid = skill_tag.split("_")[0]
last_actively_generated_node: SkillNode | None = self.data.latest_active_generation_node
if last_actively_generated_node is None or last_actively_generated_node.end_tick < tick:
return True
if cid in last_actively_generated_node.skill_tag:
return True
else:
if last_actively_generated_node.apl_unit is None:
raise ValueError(
f"{last_actively_generated_node.skill_tag}作为主动动作但是却没有APLUnit！"
)
if last_actively_generated_node.apl_unit.apl_unit_type == "action.no_swap_cancel+=":
"""
当前台技能的apl_unit非空（意味着前台技能来自于APL模块），
并且apl_unit的种类为“action.no_swap_cancel+=”，即合轴禁止类型，则不可切人。
"""
self._swap_cancel_debug_print(
mode=5,
skill_tag=skill_tag,
last_actively_generated_node=last_actively_generated_node,
)
return False
return True
def check_myself(self):
if self.data.preload_action_list_before_confirm:
self.active_signal = True
def _swap_cancel_debug_print(
self,
mode: int,
skill_tag: str,
last_actively_generated_node: SkillNode | None = None,
):
if not SWAP_CANCEL_MODE_DEBUG:
return
"""由于APL的SwapCancelEngine基本会看每个tick都调用，所以这里需要避免重复播报。"""
if self.__report_tag == skill_tag:
return
self.__report_tag = skill_tag
skill_compare = True if SWAP_CANCEL_DEBUG_TARGET_SKILL else False
if mode == 0:
print("APL返回的结果是wait！")
elif mode == 1:
(
print(f"{skill_tag}所涉及角色当前没空！")
if not skill_compare
else (
print(f"{skill_tag}所涉及角色当前没空！")
if skill_tag == SWAP_CANCEL_DEBUG_TARGET_SKILL
else None
)
)
elif mode == 2:
(
print(f"{skill_tag}所涉及角色当前tick存在任务冲突，合轴失败！")
if not skill_compare
else (
print(
f"{skill_tag}所涉所涉及角色当前tick存在任务冲突，合轴失败！及角色当前没空！"
)
if skill_tag == SWAP_CANCEL_DEBUG_TARGET_SKILL
else None
)
)
elif mode == 3:
(
print(f"{skill_tag}所涉及角色切人CD未就绪 或是 技能优先级低于前台技能，合轴失败！")
if not skill_compare
else (
print(
f"{skill_tag}所涉及角色切人CD未就绪 或是 技能优先级低于前台技能，合轴失败！"
)
if skill_tag == SWAP_CANCEL_DEBUG_TARGET_SKILL
else None
)
)
elif mode == 4:
(
print(f"当前tick不满足{skill_tag}合轴所需的时间！")
if not skill_compare
else (
print(f"当前tick不满足{skill_tag}合轴所需的时间！")
if skill_tag == SWAP_CANCEL_DEBUG_TARGET_SKILL
else None
)
)
elif mode == 5:
if last_actively_generated_node:
(
print(
f"{skill_tag}的上一个主动动作{last_actively_generated_node.skill.skill_tag}的APL策略为不要合轴！"
)
if not skill_compare
else (
print(
f"{skill_tag}的上一个主动动作{last_actively_generated_node.skill.skill_tag}的APL策略为不要合轴！"
)
if skill_tag == SWAP_CANCEL_DEBUG_TARGET_SKILL
else None
)
)
else:
raise ValueError("mode参数错误！")
================================================
FILE: zsim/sim_progress/Preload/PreloadEngine/__init__.py
================================================
from .APLEngine import APLEngine
from .AttackAnswerEngine import AttackResponseEngine
from .BasePreloadEngine import BasePreloadEngine
from .ConfirmEngine import ConfirmEngine
from .ForceAddEngine import ForceAddEngine
from .SwapCancelValidateEngine import SwapCancelValidateEngine
__all__ = [
"APLEngine",
"BasePreloadEngine",
"ForceAddEngine",
"ConfirmEngine",
"SwapCancelValidateEngine",
"AttackResponseEngine",
]
================================================
FILE: zsim/sim_progress/Preload/PreloadStrategy.py
================================================
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
from zsim.models.event_enums import SpecialStateUpdateSignal as SSUS
from zsim.sim_progress.Preload.PreloadEngine import (
APLEngine,
AttackResponseEngine,
ConfirmEngine,
ForceAddEngine,
SwapCancelValidateEngine,
)
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
from .PreloadDataClass import PreloadData
class BasePreloadStrategy(ABC):
"""基础策略，无论是什么策略，都会包含 APL、强制添加技能以及最终技能确认三个引擎。"""
def __init__(self, data, apl_path):
self.data: "PreloadData" = data
self.apl_engine = APLEngine(data, apl_path=apl_path)
self.force_add_engine = ForceAddEngine(data)
self.confirm_engine = ConfirmEngine(data)
self.finish_post_init: bool = False # 是否完成了后置初始化
@abstractmethod
def generate_actions(self, *args, **kwargs):
pass
@abstractmethod
def check_myself(self, *args, **kwargs):
pass
@abstractmethod
def reset_myself(self):
pass
class SwapCancelStrategy(BasePreloadStrategy):
def __init__(self, data, apl_path: str | None):
super().__init__(data, apl_path=apl_path)
self.swap_cancel_engine = SwapCancelValidateEngine(data)
self.attack_response_engine = AttackResponseEngine(
data=data, sim_instance=self.data.sim_instance
)
self.tick = 0
def generate_actions(self, enemy, tick: int) -> None:
"""合轴逻辑"""
# 0、自检
self.check_myself(enemy, tick)
assert self.data.sim_instance is not None
self.data.sim_instance.schedule_data.enemy.special_state_manager.broadcast_and_update(
signal=SSUS.BEFORE_PRELOAD
)
# 0.5、 EnemyAttack结构运行一次
self.attack_response_engine.run_myself(tick=tick)
# 1、APL引擎抛出本tick的主动动作
apl_skill_node = self.apl_engine.run_myself(tick)
if apl_skill_node is not None:
apl_skill_tag = apl_skill_node.skill_tag
priority = apl_skill_node.apl_priority
else:
apl_skill_tag = "wait"
apl_skill_node = None
priority = 0
# print(apl_skill_tag, priority)
# TODO：新增功能：Enemy进攻模块的反馈接口，即招架后Enemy动作被打断；或是角色动作被Enemy打断的功能；
# TODO：“破招”事件需通过decibel manager向角色发放对应的喧响值奖励；
# 2、ForceAdd引擎处理旧有的强制添加逻辑；
self.force_add_engine.run_myself(tick)
# 3、SwapCancel引擎 判定当前tick和技能是否能够成功合轴
self.swap_cancel_engine.run_myself(
apl_skill_tag, tick, apl_priority=priority, apl_skill_node=apl_skill_node
)
if (
self.swap_cancel_engine.active_signal
or self.force_add_engine.active_signal
or self.swap_cancel_engine.external_update_signal
):
# 4、Confirm引擎 清理data.preload_action_list_before_confirm，
self.confirm_engine.run_myself(
tick, apl_skill_node=apl_skill_node, apl_skill_tag=apl_skill_tag
)
def check_myself(self, enemy, tick, *args, **kwargs):
"""准备工作"""
if not self.finish_post_init:
self.post_init_all_object()
self.finish_post_init = True
self.data.chek_myself_before_start_preload(enemy, tick)
def reset_myself(self):
pass
def post_init_all_object(self):
"""后置初始化所有数据"""
assert self.data.sim_instance is not None
sim_instance: Simulator = self.data.sim_instance
for char_obj in sim_instance.char_data.char_obj_list:
char_obj.POST_INIT_DATA(sim_instance=sim_instance)
class SequenceStrategy:
def generate_actions(self):
# 封装顺序生成逻辑
pass
================================================
FILE: zsim/sim_progress/Preload/SkillsQueue.py
================================================
import threading
import uuid
from typing import TYPE_CHECKING, Iterable
import pandas as pd
from zsim.define import ELEMENT_TYPE_MAPPING as ETM
from zsim.define import ElementType, config
from zsim.sim_progress.Character.skill_class import Skill
from zsim.sim_progress.data_struct.LinkedList import LinkedList
from zsim.sim_progress.Report import report_to_log
if TYPE_CHECKING:
from zsim.sim_progress.Load import LoadingMission
class SkillNode:
_instance_counter = 0
_counter_lock = threading.Lock()
def __init__(
self,
skill: Skill.InitSkill,
preload_tick: int,
active_generation: bool = False,
apl_unit=None,
**kwargs,
):
"""
预加载技能节点
包含：
1、部分需要立即调用的信息；
2、整个 Skill.InitSkill 对象，包含了技能的全部信息，用于计算器调用
"""
with SkillNode._counter_lock:
self.apl_priority: int = kwargs.get("apl_priority", 0)
self.apl_unit = apl_unit
self.skill_tag: str = skill.skill_tag
self.char_name: str = skill.char_name
self.preload_tick: int = preload_tick
self.hit_times: int = skill.hit_times
self.labels: dict[str, list[str] | str | int | float] | None = skill.labels
self.skill: Skill.InitSkill = skill
self.end_tick: int = self.preload_tick + self.skill.ticks
self.active_generation: bool = active_generation # 构造函数的调用来源是否是主动动作
# TODO：后续需用UUID替换skill_node实例ID
self.instance_id = SkillNode._instance_counter
SkillNode._instance_counter += 1
# 生成 UUID
self.UUID = uuid.uuid4()
tick_list = []
if self.skill.tick_list:
for hit_tick in self.skill.tick_list:
tick_key = self.preload_tick + hit_tick
tick_list.append(tick_key)
else:
time_step = (self.skill.ticks - 1) / (self.hit_times + 1)
for i in range(self.hit_times):
tick_key = self.preload_tick + time_step * (i + 1)
tick_list.append(tick_key)
self.tick_list = tick_list
self.loading_mission: "LoadingMission | None" = None
self._effective_anomaly_buildup: bool = True
self._element_type_change: ElementType | None = None
self.force_qte_trigger: bool = False
@property
def is_additional_damage(self) -> bool:
"""判断当前技能是否为额外伤害"""
if self.skill.labels is None:
return False
else:
if "additional_damage" in self.skill.labels:
return True
else:
return False
@property
def element_type(self) -> ElementType:
"""返回当前的属性种类！（考虑染色）"""
if self._element_type_change is None:
return self.skill.element_type
else:
return self._element_type_change
@property
def element_type_change(self) -> ElementType | None:
"""技能的染色"""
return self._element_type_change
@element_type_change.setter
def element_type_change(self, value: ElementType | None):
if self._element_type_change is not None:
raise ValueError(
f"技能{self.skill_tag}已经被染色为【{ETM.get(self._element_type_change)}】属性！不能被重复染色！"
)
self._element_type_change = value
@property
def effective_anomaly_buildup(self) -> bool:
"""判断技能是否为异常技能"""
return self._effective_anomaly_buildup
@effective_anomaly_buildup.setter
def effective_anomaly_buildup(self, value: bool):
self._effective_anomaly_buildup = value
def __str__(self) -> str:
return f"SkillNode: {self.skill_tag}"
@classmethod
def get_total_instances(cls) -> int:
"""获取当前skill_node的唯一ID，该ID在skill_node被构造时就已经确定"""
return cls._instance_counter
def have_label(self, label_key: str):
"""判断当前skill_node是否拥有传入数值的skill_label"""
if self.skill.labels is None:
return False
if self.labels is not None and label_key in self.labels.keys():
return True
else:
return False
def is_heavy_hit(self, tick: int) -> bool:
"""判断当前技能是否为重击"""
if not self.skill.heavy_attack:
return False
last_hit = self.tick_list[-1]
if tick - 1 < last_hit <= tick:
return True
else:
return False
def is_hit_now(self, tick: int) -> bool:
"""判断当前技能是否命中"""
for tick_key in self.tick_list:
if tick - 1 < tick_key <= tick:
return True
continue
else:
return False
def is_last_hit(self, tick: int):
"""判断当前tick是否存在最后一击"""
if not self.is_hit_now(tick):
return False
else:
return tick - 1 < self.tick_list[-1] <= tick
def spawn_node(tag: str, preload_tick: int, skills: Iterable[Skill], **kwargs) -> SkillNode:
"""
通过输入的tag和preload_tick，直接创建SkillNode。
"""
active_generation = kwargs.get("active_generation", False)
apl_priority = kwargs.get("apl_priority", 0)
apl_unit = kwargs.get("apl_unit", None)
for obj in skills:
if tag in obj.skills_dict.keys():
node = SkillNode(
obj.skills_dict[tag],
preload_tick,
active_generation,
apl_priority=apl_priority,
apl_unit=apl_unit,
)
return node
else:
raise ValueError(
f"预加载技能 {tag} 不存在于输入的 Skill 类中，请检查输入, "
f"当前技能列表为：{[(skill.name, skill.skills_dict.keys()) for skill in skills]}"
)
def get_skills_queue(
preload_table: pd.DataFrame,
*skills: Skill,
) -> tuple[int, LinkedList]:
"""
提取dataframe中，‘skill_tag’列的信息
并将其与输入的 Skill 类比对
可输入任意数量的 Skill 类比对。
示例：
get_skills_queue(dataframe,
skills = Skill( name='艾莲'),
skills_2 = Skill(name = '苍角'),
skills_3 = Skill(name = '莱卡恩'))
返回：一个链表，包含全部可被预加载的 SkillNode
"""
# 输入类型检查
if not isinstance(preload_table, pd.DataFrame):
raise TypeError("预加载序列表必须是 pandas.DataFrame 类型")
if not all(isinstance(x, Skill) for x in skills):
raise TypeError("输入的技能必须是 Skill 类")
skills_queue = LinkedList() # 用于储存技能节点
preload_skills: pd.Series = pd.Series()
try:
preload_skills: pd.Series = preload_table["skill_tag"] # 传入的数据必须包含 skill_tag 列
except KeyError:
print("提供错误的预加载序列表，请检查输入")
# 确保技能列表不为空
if not preload_skills.empty:
preload_skills_list: list[str] = preload_skills.tolist()
else:
raise ValueError("预加载序技能列表为空")
preload_tick_stamps = {skill.CID: 0 for skill in skills}
if not config.apl_mode.enabled:
for tag in preload_skills_list:
cid = int(tag[:4]) # 提取tag的前四个字符作为key
if cid not in preload_tick_stamps:
raise ValueError(f"技能 {tag} 的CID不在输入的技能列表中，请检查输入")
try:
# 在__main__中寻找tick变量，并与preload_tick_stamp比较
tick = globals().get("tick", 0)
preload_tick_stamp = max(
preload_tick_stamps[cid], tick
) # 取最大值作为preload_tick_stamp
node = spawn_node(tag, preload_tick_stamp, skills)
skills_queue.add(node)
preload_tick_stamps[cid] = (
preload_tick_stamp + node.skill.ticks
) # 更新preload_tick_stamp
report_to_log(
f"[PRELOAD]:预加载节点 {tag} 已创建，将在 {preload_tick_stamps[cid]} 执行",
level=2,
)
except ValueError as e:
raise ValueError(str(e))
return max(preload_tick_stamps.values()), skills_queue
if __name__ == "__main__":
pass
================================================
FILE: zsim/sim_progress/Preload/__init__.py
================================================
from . import SkillsQueue, watchdog
from .APLModule.APLClass import APLClass
from .APLModule.APLJudgeTools import find_char, get_game_state
from .APLModule.APLParser import APLParser
from .PreloadClass import PreloadClass
from .PreloadDataClass import PreloadData
from .SkillsQueue import SkillNode
__all__ = [
"watchdog",
"SkillsQueue",
"SkillNode",
"APLParser",
"APLClass",
"find_char",
"get_game_state",
"PreloadClass",
"PreloadData",
]
================================================
FILE: zsim/sim_progress/Preload/apl_unit/APLUnit.py
================================================
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING
from zsim.define import compare_methods_mapping
from ..APLModule.SubConditionUnit import (
ActionSubUnit,
AttributeSubUnit,
BaseSubConditionUnit,
BuffSubUnit,
SpecialSubUnit,
StatusSubUnit,
)
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class APLUnit(ABC):
def __init__(self, sim_instance: "Simulator"):
"""一行APL就是一个APLUnit，它是所有APLUnit的基类。"""
self.priority = 0
self.char_CID = None
self.break_when_found_action = True
self.result = None
self.sub_conditions_unit_list = []
self.sub_conditions_ast = None
self.apl_unit_type = None
self.sim_instance = sim_instance
@abstractmethod
def check_all_sub_units(self, found_char_dict, game_state, sim_instance: "Simulator", **kwargs):
pass
def evaluate_condition_ast(
self, node: "ExprNode", found_char_dict, game_state, sim_instance, tick, result_box
):
"""递归地评估逻辑树的表达式节点"""
if node.is_leaf():
if not isinstance(node.sub_condition, BaseSubConditionUnit):
raise TypeError("逻辑树中包含非 BaseSubConditionUnit 类型的叶子节点")
result = node.sub_condition.check_myself(
found_char_dict, game_state, tick=tick, sim_instance=sim_instance
)
result_box.append(result)
return result
else:
left_result = self.evaluate_condition_ast(
node.left, found_char_dict, game_state, sim_instance, tick, result_box
)
right_result = self.evaluate_condition_ast(
node.right, found_char_dict, game_state, sim_instance, tick, result_box
)
if node.operator == "and":
return left_result and right_result
elif node.operator == "or":
return left_result or right_result
else:
raise ValueError(f"未知逻辑运算符: {node.operator}")
def spawn_sub_condition(
priority: int, sub_condition_code: str = None
) -> ActionSubUnit | BuffSubUnit | StatusSubUnit | AttributeSubUnit | ActionSubUnit:
"""解构apl子条件字符串，并且组建出构建sub_condition类需要的构造字典"""
logic_mode = 0
sub_condition_dict = {}
code_head = sub_condition_code.split(":")[0]
if "special" not in code_head and "." not in code_head:
raise ValueError(f"不正确的条件代码！{sub_condition_code}")
if code_head.startswith("!"):
code_head = code_head[1:]
logic_mode = 1
sub_condition_dict["type"] = code_head.split(".")[0]
sub_condition_dict["target"] = code_head.split(".")[1]
code_body = sub_condition_code.split(":")[1]
for _operator in [">=", "<=", "==", ">", "<", "!="]:
if _operator in code_body:
sub_condition_dict["operation_type"] = compare_methods_mapping[_operator]
sub_condition_dict["stat"] = code_body.split(_operator)[0]
sub_condition_dict["value"] = code_body.split(_operator)[1]
break
else:
raise ValueError(f"不正确的计算符！{code_body}")
sub_condition_output = sub_condition_unit_factory(priority, sub_condition_dict, mode=logic_mode)
return sub_condition_output
def sub_condition_unit_factory(priority: int, sub_condition_dict: dict = None, mode=0):
"""根据传入的dict，来构建不同的子条件单元"""
condition_type = sub_condition_dict["type"]
if condition_type not in ["status", "attribute", "buff", "action", "special"]:
raise ValueError(f"不正确的条件类型！{sub_condition_dict['type']}")
if condition_type == "status":
return StatusSubUnit(priority, sub_condition_dict, mode)
elif condition_type == "attribute":
return AttributeSubUnit(priority, sub_condition_dict, mode)
elif condition_type == "buff":
return BuffSubUnit(priority, sub_condition_dict, mode)
elif condition_type == "action":
return ActionSubUnit(priority, sub_condition_dict, mode)
elif condition_type == "special":
return SpecialSubUnit(priority, sub_condition_dict, mode)
else:
raise ValueError(f"special类的APL解析，是当前尚未开发的功能！优先级为{priority}，")
class SimpleUnitForForceAdd(APLUnit):
def __init__(self, condition_list, sim_instance: "Simulator" = None):
super().__init__(sim_instance=sim_instance)
self.whole_line = condition_list
for condition_str in condition_list:
self.sub_conditions_unit_list.append(spawn_sub_condition(self.priority, condition_str))
def check_all_sub_units(self, found_char_dict, game_state, sim_instance: "Simulator", **kwargs):
if self.sim_instance is None:
self.sim_instance = sim_instance
result_box = []
tick = kwargs.get("tick", None)
if not self.sub_conditions_unit_list:
return True, result_box
for sub_units in self.sub_conditions_unit_list:
if not isinstance(sub_units, BaseSubConditionUnit):
raise TypeError("ActionAPLUnit类的sub_conditions_unit_list中的对象构建不正确！")
result = sub_units.check_myself(
found_char_dict, game_state, tick=tick, sim_instance=sim_instance
)
result_box.append(result)
if not result:
return False, result_box
else:
return True, result_box
class ExprNode:
def __init__(
self, operator=None, left=None, right=None, sub_condition: "BaseSubConditionUnit" = None
):
"""
- operator: "and", "or"（逻辑运算符）
- left/right: ExprNode 对象
- sub_condition: 原子条件（BaseSubConditionUnit 的实例），只在叶子节点设置
"""
self.operator = operator
self.left = left
self.right = right
self.sub_condition = sub_condition
def is_leaf(self):
return self.operator is None
def logic_tree_to_expr_node(priority: int, logic_tree: dict | str | None) -> ExprNode | None:
if logic_tree is None:
return None
# 如果是字符串（最小条件单元），构造叶子节点
if isinstance(logic_tree, str):
return ExprNode(sub_condition=spawn_sub_condition(priority, logic_tree))
# 应该只有一个操作符键
assert isinstance(logic_tree, dict) and len(logic_tree) == 1
operator = list(logic_tree.keys())[0]
children = logic_tree[operator]
# 如果只有两个元素，直接构造左右节点
if len(children) == 2:
left_node = logic_tree_to_expr_node(priority, children[0])
right_node = logic_tree_to_expr_node(priority, children[1])
return ExprNode(operator=operator, left=left_node, right=right_node)
# 如果超过两个，需要递归构造嵌套结构（左结合）
current = logic_tree_to_expr_node(priority, children[0])
for i in range(1, len(children)):
right = logic_tree_to_expr_node(priority, children[i])
current = ExprNode(operator=operator, left=current, right=right)
return current
================================================
FILE: zsim/sim_progress/Preload/apl_unit/ActionAPLUnit.py
================================================
from typing import TYPE_CHECKING
from .APLUnit import APLUnit
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class ActionAPLUnit(APLUnit):
def __init__(self, apl_unit_dict: dict, sim_instance: "Simulator" = None):
"""动作类APL"""
super().__init__(sim_instance=sim_instance)
self.char_CID = apl_unit_dict["CID"]
self.priority = apl_unit_dict["priority"]
self.apl_unit_type = apl_unit_dict["type"]
self.break_when_found_action = True
self.result = apl_unit_dict["action"]
self.whole_line = apl_unit_dict.get("whole_line", None)
from zsim.sim_progress.Preload.apl_unit.APLUnit import (
logic_tree_to_expr_node,
spawn_sub_condition,
)
for condition_str in apl_unit_dict["conditions"]:
self.sub_conditions_unit_list.append(spawn_sub_condition(self.priority, condition_str))
self.sub_conditions_ast = logic_tree_to_expr_node(
self.priority, apl_unit_dict.get("conditions_tree", None)
)
self.builtin_percond_list: list = []
if self.result == "assault_after_parry": # 对于突击支援，需要添加一项内置的条件检查。
"""APL脚本代码：action.CID:positive_linked_after==CID_knock_back_cause_parry"""
precond_str_1 = f"action.{self.char_CID}:strict_linked_after=={self.char_CID}_knock_back_cause_parry"
precond_str_2 = f"special.preload_data:operating_char=={self.char_CID}"
for precond in [precond_str_1, precond_str_2]:
self.builtin_percond_list.append(spawn_sub_condition(self.priority, precond))
def check_all_sub_units(self, found_char_dict, game_state, sim_instance: "Simulator", **kwargs):
"""单行APL的逻辑函数：检查所有子条件并且输出结果"""
result_box = []
tick = kwargs.get("tick", None)
if self.builtin_percond_list:
for precond_unit in self.builtin_percond_list:
if not precond_unit.check_myself(
found_char_dict, game_state, tick=tick, sim_instance=sim_instance
):
return False, result_box
if not self.sub_conditions_unit_list:
"""无条件直接输出True"""
return True, result_box
if self.sub_conditions_ast is None:
return True, result_box
final_result = self.evaluate_condition_ast(
self.sub_conditions_ast, found_char_dict, game_state, sim_instance, tick, result_box
)
# 下列代码块是用于检查QTE是否在重复释放上符合规则（即QTE是否已经被响应过了）
if "QTE" in self.result:
enemy = self.sim_instance.schedule_data.enemy
qte_manager = enemy.qte_manager
qte_leagal = qte_manager.check_qte_legality(qte_skill_tag=self.result)
else:
qte_leagal = True
final_final_result = final_result and qte_leagal
return final_final_result, result_box
================================================
FILE: zsim/sim_progress/Preload/apl_unit/AtkResponseAPLUnit.py
================================================
from typing import TYPE_CHECKING
from zsim.sim_progress.Preload.apl_unit.APLUnit import APLUnit
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class AtkResponseAPLUnit(APLUnit):
def __init__(self, apl_unit_dict: dict, sim_instance: "Simulator" = None):
"""动作响应类APL"""
super().__init__(sim_instance=sim_instance)
self.char_CID = apl_unit_dict["CID"]
self.priority = apl_unit_dict["priority"]
self.apl_unit_type = apl_unit_dict["type"]
self.whole_line = apl_unit_dict.get("whole_line", None)
self.response_proactive_level = None # 进攻响应APL的主动响应等级
if self.apl_unit_type.split("_")[-1] == "positive+=":
self.response_proactive_level = 1
elif self.apl_unit_type.split("_")[-1] == "balance+=":
self.response_proactive_level = 0
else:
raise ValueError(
f"不正确的进攻响应APL类型：{self.apl_unit_type}，只能是positive或balance！"
)
if "atk_response" not in self.apl_unit_type:
raise ValueError("企图对非进攻响应APL构造AtkResponseAPLUnit类！")
self.break_when_found_action = True
self.result = apl_unit_dict["action"]
from zsim.sim_progress.Preload.apl_unit.APLUnit import (
logic_tree_to_expr_node,
spawn_sub_condition,
)
for condition_str in apl_unit_dict["conditions"]:
self.sub_conditions_unit_list.append(spawn_sub_condition(self.priority, condition_str))
self.sub_conditions_ast = logic_tree_to_expr_node(
self.priority, apl_unit_dict.get("conditions_tree", None)
)
self.common_response_tag_list = ["parry", "dodge"]
def check_all_sub_units(self, found_char_dict, game_state, sim_instance: "Simulator", **kwargs):
"""仅供模式下的单行APL的逻辑函数：检查所有子条件并且输出结果"""
result_box = []
tick = kwargs.get("tick", None)
if tick is None:
tick = self.sim_instance.tick
if not self.check_atk_response_conditions(tick):
"""如果进攻响应的前置条件不满足，直接返回False"""
return False, result_box
"""在进行附加条件的检查之前，先检查当前时间是否符合响应策略积极度"""
if not self.check_response_tick(tick):
return False, result_box
if self.sub_conditions_ast is None:
return True, result_box
final_result = self.evaluate_condition_ast(
self.sub_conditions_ast, found_char_dict, game_state, sim_instance, tick, result_box
)
return final_result, result_box
def check_atk_response_conditions(self, tick: int) -> bool:
"""检查进攻响应的前置条件是否满足"""
atk_manager = self.sim_instance.preload.preload_data.atk_manager
if not atk_manager.attacking:
# print("当前没有正在进行的进攻事件，无法响应！")
return False
if atk_manager.is_answered:
# print("当前进攻事件已经被响应，无法再次响应！")
return False
rt_tick = atk_manager.get_rt()
can_be_answered_result_tuple: tuple = atk_manager.can_be_answered(rt_tick=rt_tick)
if not can_be_answered_result_tuple[0]:
print(
f"当前进攻事件无法在第{tick}tick被响应，当前的响应窗口为{can_be_answered_result_tuple}"
)
return False
return True
def check_response_tick(self, tick: int) -> bool:
"""检查当前tick是否符合响应策略积极度"""
proactive_level = self.response_proactive_level
atk_manager = self.sim_instance.preload.preload_data.atk_manager
response_window: tuple[int, int]
skill_tick: int = 0
if any([common_tag in self.result for common_tag in self.common_response_tag_list]):
response_window = (
atk_manager.interaction_window_open_tick,
atk_manager.interaction_window_close_tick,
)
else:
"""如果技能并非常规响应动作（如强化E、大招等），则需要获取技能的具体ticks，来计算新的响应窗口。"""
cid: int = int(self.char_CID)
skill_obj_list = self.sim_instance.preload.preload_data.skills
for _skill_obj in skill_obj_list:
if cid == _skill_obj.CID:
skill_obj = _skill_obj
break
else:
raise ValueError(f"没有找到CID为{cid}的技能对象！")
skill_tick: int = skill_obj.get_skill_info(skill_tag=self.result, attr_info="ticks")
response_window = atk_manager.get_uncommon_response_window(another_ta=skill_tick)
if proactive_level == 0:
"""在平衡策略下，响应动作需要尽量晚一些执行，所以检测右边界
但是又不能完全和右边界重合，因为那样太晚了，所以我们就让它提早一帧放行。"""
if tick + 1 == response_window[1]:
return True
elif proactive_level == 1:
from zsim.define import ENEMY_ATK_PARAMETER_DICT
if skill_tick != 0 and skill_tick < ENEMY_ATK_PARAMETER_DICT["Taction"]:
print(
f"Warning: 技能 {self.result} 的ticks小于基础参数Taction，这会导致响应窗口的左边界不正确！所以直接于左边界处拦截，直接返回False。"
)
"""
但若是这个响应动作的时间小于30tick，则一定会引起响应失败。
在EnemyAttackAction中的get_first_hit的方法中，这一定会引起报错。
为了保证程序的运行，我需要提前拦截这种错误，让本函数返回False并且输出错误信息。
"""
return False
"""在积极策略下，响应动作需要尽量早一些执行，所以检测左边界"""
if tick == response_window[0]:
return True
else:
raise ValueError(
f"不正确的进攻响应APL的主动响应等级：{self.response_proactive_level}！"
)
return False
================================================
FILE: zsim/sim_progress/Preload/apl_unit/__init__.py
================================================
================================================
FILE: zsim/sim_progress/Preload/watchdog.py
================================================
from typing import TYPE_CHECKING
from zsim.define import ENABLE_WATCHDOG, WATCHDOG_LEVEL
from zsim.sim_progress.Report import report_to_log
if TYPE_CHECKING:
from zsim.sim_progress.Character.skill_class import Skill
from zsim.sim_progress.Preload.SkillsQueue import SkillNode
if ENABLE_WATCHDOG:
report_to_log("[INFO] Watchdog is enabled.", level=4)
def watch_reverse_order(
current_node: "SkillNode | Skill.InitSkill",
last_node: "SkillNode | Skill.InitSkill | None",
) -> bool | None:
"""
监控技能队列中的技能加载顺序，如果发现逆序加载则发出警告。
该函数检查当前节点和上一个节点的技能标签，判断是否存在逆序加载的情况。
逆序加载指的是技能队列中本应先加载的技能后于其他技能加载，这可能是数据顺序错误或技能依赖关系处理不当导致的。
参数:
current_node: 当前正在检查的技能节点，可以是SkillsQueue.SkillNode或Skill_Class.Skill.InitSkill类型。
last_node: 上一个已加载的技能节点，作为参考与当前节点比较。
返回值:
无。如果检测到逆序加载，会打印警告信息。
"""
if not ENABLE_WATCHDOG:
return None
if WATCHDOG_LEVEL <= 0:
return None
if last_node is None:
return None
if not (isinstance(current_node, SkillNode) or isinstance(current_node, Skill.InitSkill)):
return None
if not (isinstance(last_node, SkillNode) or isinstance(last_node, Skill.InitSkill)):
return None
current_tag = current_node.skill_tag
last_tag = last_node.skill_tag
if current_tag[:-1] == last_tag[:-1]:
if current_tag[-1] < last_tag[-1]:
feedback = (
f"[WARNING] Watchdog detected a reverse order preload event:"
f"Is {current_tag} really behind of {last_tag}?"
)
print(feedback)
report_to_log(feedback, level=0)
return False
return True
class WatchDog:
def __init__(self, **kwargs):
try:
watch_reverse_order(**kwargs)
except AttributeError:
pass
================================================
FILE: zsim/sim_progress/RandomNumberGenerator/__init__.py
================================================
import random
import threading
import time
from functools import lru_cache
from typing import TYPE_CHECKING
import numpy as np
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
MAX_SIGNED_INT64: int = 2**63 - 1
class RNG:
_instances = {}
_lock = threading.Lock()
def __new__(cls, sim_instance: "Simulator"):
"""为了RNG增加进程锁"""
with cls._lock:
if sim_instance not in cls._instances:
instance = super().__new__(cls)
cls._instances[sim_instance] = instance
return cls._instances[sim_instance]
def __init__(self, sim_instance: "Simulator"):
"""RNG的构造函数，每个进程只执行一次，反复调用构造函数会报错。"""
if not hasattr(self, "_initialized"):
self.seed: int | None = None
self.r: int | None = None
self.sim_instance = sim_instance
self.reseed()
self._initialized = True
self.NORMAL_TABLE_SIZE = 10000
self.normal_table = None
def get_seed(self) -> int:
assert self.seed is not None
return self.seed
def reseed(self, new_seed: int | None = None):
if self.sim_instance is None:
raise ValueError("RNG模块在初始化时，并未传入Simulator对象")
if self.sim_instance.in_parallel_mode:
# 当多进程模式时，seed的创造应该基于进程的UUID
assert self.sim_instance.sim_cfg is not None
run_turn_uuid: str | None = self.sim_instance.sim_cfg.run_turn_uuid
if run_turn_uuid is None:
raise ValueError("多进程模式下，sim_cfg中必须存在有效的run_turn_uuid")
hashed_uuid = abs(hash(run_turn_uuid)) % (2**63)
tick = self.sim_instance.tick
new_seed = (hashed_uuid + tick) if new_seed is None else (new_seed + tick)
else:
# 当单进程模式时，seed的创造应该基于当前的time()返回的结果
tick = self.sim_instance.tick
if new_seed is None:
new_seed = int(time.time() * 1000000) + tick
else:
new_seed = int(new_seed) + tick
(self.seed, self.r) = self.generate_random_number(new_seed)
random.seed(self.seed)
def random_float(self) -> float:
return random.uniform(0.0, 1.0)
@staticmethod
@lru_cache(maxsize=4)
def generate_random_number(seed: int) -> tuple[int, int]:
random.seed(seed)
random_number = random.randint(a=-MAX_SIGNED_INT64, b=MAX_SIGNED_INT64)
return seed, random_number
def generate_and_judge(self, possibility: float) -> bool:
self.seed, self.r = self.generate_random_number(self.seed)
return np.abs(self.r) < possibility * MAX_SIGNED_INT64
def normal_from_table(self) -> float:
"""生成正态分布的随机数，使用预先生成的正态分布表"""
if not hasattr(self, "normal_table") or self.normal_table is None:
self.normal_table = np.random.normal(loc=0, scale=1, size=self.NORMAL_TABLE_SIZE)
rng_float = self.random_float()
idx = int(rng_float * self.NORMAL_TABLE_SIZE)
idx = min(idx, self.NORMAL_TABLE_SIZE - 1)
value = self.normal_table[idx]
return float(value)
def __deepcopy__(self, memo): # pylint: disable=unused-argument
return self # 始终返回现有实例
def __copy__(self):
return self
================================================
FILE: zsim/sim_progress/Report/__init__.py
================================================
import asyncio
import json
import logging
import os
import threading
from datetime import datetime
from typing import TYPE_CHECKING
from zsim.define import NORMAL_MODE_ID_JSON
from .buff_handler import dump_buff_csv, report_buff_to_queue
from .log_handler import async_log_writer, log_queue, report_to_log
from .result_handler import (
async_result_writer,
report_dmg_result,
result_queue,
)
__all__ = [
"report_buff_to_queue",
"report_to_log",
"report_dmg_result",
"start_report_threads",
"stop_report_threads",
]
__result_id: str = "Unknown"
__event_loop: asyncio.AbstractEventLoop | None = None # 存储事件循环的引用
if TYPE_CHECKING:
from zsim.models.session.session_run import ExecAttrCurveCfg, ExecWeaponCfg
def regen_result_id(sim_cfg: "ExecAttrCurveCfg | ExecWeaponCfg | None", *, session_id=None) -> None:
"""
根据运行模式生成结果ID并处理相关文件。
如果 `sim_cfg` 不为 None（并行模式），则结果ID由 `run_turn_uuid`, `sc_name` 和 `sc_value` 组合而成，
格式为 "./results/{run_turn_uuid}/{sc_name}_{sc_value}"。
此模式下会创建对应的结果目录，并将 `parallel_config` 对象序列化为 JSON 文件（parallel_config.json）保存在该目录中。
如果 `sim_cfg` 为 None（普通模式），则从ID缓存文件中读取现有ID，
找到最大的有效ID，生成一个新的递增ID，并将新ID和时间戳写入缓存文件。
结果ID格式为 "./results/{current_id}"。
Args:
sim_cfg: 并行配置对象，或 None。
session_id: 会话ID，在API启动的普通模式下用作传递本次运行的id。
Returns:
None. 全局变量 `__result_id` 会被更新。
"""
global __result_id
if sim_cfg is not None:
# 并行模式：session_id(API模式)/随机生成的uuid(WebUI模式) + 配置列表作为id
if sim_cfg.func == "attr_curve":
__result_id = f"./results/{sim_cfg.run_turn_uuid}/{sim_cfg.func}_{sim_cfg.sc_name}_{sim_cfg.sc_value}" # type: ignore
elif sim_cfg.func == "weapon":
__result_id = f"./results/{sim_cfg.run_turn_uuid}/{sim_cfg.func}_{sim_cfg.weapon_name}_{sim_cfg.weapon_level}" # type: ignore
# 创建结果目录
os.makedirs(__result_id, exist_ok=True)
# 将 parallel_config 保存为 JSON 文件
config_path = os.path.join(__result_id, "sub.parallel_config.json")
try:
# 尝试将 dataclass 对象转换为字典以便序列化
config_dict = sim_cfg.model_dump()
# 更换角色相对位置为角色名
index = config_dict["adjust_char"]
from zsim.define import saved_char_config
config_dict["adjust_char"] = saved_char_config["name_box"][index - 1]
with open(config_path, "w", encoding="utf-8") as f:
json.dump(config_dict, f, indent=4, ensure_ascii=False)
except TypeError as e:
# 如果转换或序列化失败，记录错误日志
raise TypeError(f"无法将 parallel_config 转换为字典: {e}") from e
elif session_id is not None:
# API启动的普通模式：使用session_id作为id
cache_path = NORMAL_MODE_ID_JSON
# 检查缓存文件是否存在，如果不存在则创建
if not os.path.exists(cache_path):
os.makedirs(os.path.dirname(cache_path), exist_ok=True)
with open(cache_path, "w") as f:
json.dump({}, f, indent=4)
with open(cache_path, "r+", encoding="utf-8") as f:
id_cache_dict = json.load(f)
if session_id in id_cache_dict.keys():
logging.warning(f"session_id {session_id} 已存在，将使用该id")
else:
id_cache_dict[session_id] = datetime.now().strftime("%Y-%m-%d_%H%M")
f.seek(0)
json.dump(id_cache_dict, f, indent=4)
f.truncate()
__result_id = f"./results/{session_id}"
else:
# CLI或WebUI启动的普通模式：使用缓存文件中的最大ID+1作为id
cache_path = NORMAL_MODE_ID_JSON
# 检查缓存文件是否存在，如果不存在则创建
if not os.path.exists(cache_path):
os.makedirs(os.path.dirname(cache_path), exist_ok=True)
with open(cache_path, "w") as f:
json.dump({}, f, indent=4)
# 读取缓存文件
with open(cache_path, "r+") as f:
try:
id_cache_dict = json.load(f)
except json.decoder.JSONDecodeError:
id_cache_dict = {}
valid_ids = []
# 筛选出有效的整数ID
for key in id_cache_dict.keys():
try:
valid_ids.append(int(key))
except ValueError:
continue
# 确定新的ID
if valid_ids:
current_id = max(valid_ids) + 1
else:
current_id = 0
# 将新ID和当前时间戳添加到缓存字典中
id_cache_dict[str(current_id)] = datetime.now().strftime("%Y-%m-%d_%H%M")
f.seek(0)
# 将更新后的缓存字典写回文件
json.dump(id_cache_dict, f, indent=4)
# 截断文件到当前写入位置
f.truncate()
# 更新全局结果ID
__result_id = f"./results/{current_id}"
def start_async_tasks():
"""启动异步任务处理日志和结果写入"""
# 在新线程中运行事件循环
def run_event_loop():
global __event_loop
# 如果已有事件循环在运行，则不再创建新的
if __event_loop is not None:
return
# 创建新的事件循环
__event_loop = asyncio.new_event_loop()
asyncio.set_event_loop(__event_loop)
__event_loop.create_task(async_log_writer(__result_id))
__event_loop.create_task(async_result_writer(__result_id))
__event_loop.run_forever()
loop_thread = threading.Thread(target=run_event_loop, daemon=True)
loop_thread.start()
def start_report_threads(sim_cfg, *, session_id=None):
"""用于在开始模拟时启动线程以处理日志和结果写入。"""
regen_result_id(sim_cfg, session_id=session_id)
start_async_tasks()
def stop_report_threads():
dump_buff_csv(__result_id)
log_queue.join()
result_queue.join()
================================================
FILE: zsim/sim_progress/Report/buff_handler.py
================================================
import os
from collections import defaultdict
import polars as pl
from zsim.define import DEBUG, DEBUG_LEVEL
buffered_data: dict[str, dict[int, dict[str, int]]] = defaultdict(
lambda: defaultdict(lambda: defaultdict(int))
)
def report_buff_to_queue(
character_name: str, time_tick, buff_name: str, buff_count, all_match: bool, level=4
):
if DEBUG and DEBUG_LEVEL <= level:
if all_match:
# 由于Buff的log录入总是在下个tick的开头，所以这里的time_tick要-1
buffered_data[character_name][time_tick - 1][buff_name] += buff_count
def dump_buff_csv(result_id: str):
# Check if buffered_data has any content
if not buffered_data:
return
for char_name, char_data in buffered_data.items():
if not char_data:
continue
# 收集所有可能的buff名称
all_buff_names = set()
for buffs in char_data.values():
all_buff_names.update(buffs.keys())
# 构建行数据，确保所有行都有相同的列
rows = []
for tick, buffs in char_data.items():
row = {"time_tick": tick}
# 确保所有可能的 buff 列都存在于每行中
for buff_name in all_buff_names:
row[buff_name] = buffs.get(buff_name, 0)
rows.append(row)
if not rows:
continue
buff_report_file_path = f"{result_id}/buff_log/{char_name}.csv"
# Ensure the directory exists
try:
os.makedirs(os.path.dirname(buff_report_file_path), exist_ok=True)
except Exception:
continue
# Create DataFrame and sort columns
try:
df = pl.DataFrame(rows)
if df.is_empty():
continue
# Sort columns: time_tick first, then buff names alphabetically for deterministic output.
buff_columns = sorted([col for col in df.columns if col != "time_tick"])
df = df.sort("time_tick").select(["time_tick"] + buff_columns)
# Write CSV file
df.write_csv(buff_report_file_path, include_bom=True)
except Exception:
pass
================================================
FILE: zsim/sim_progress/Report/log_handler.py
================================================
import asyncio
import os
import queue
import aiofiles
from zsim.define import DEBUG, DEBUG_LEVEL
log_queue: queue.Queue = queue.Queue()
def report_to_log(content: str | None = None, level=4) -> None:
if not DEBUG or content is None:
return
if DEBUG and DEBUG_LEVEL <= level:
log_queue.put(content)
async def async_log_writer(result_id: str):
report_file_path = f"./logs/{result_id}.log".replace("./results/", "")
os.makedirs(os.path.dirname(report_file_path), exist_ok=True)
while True:
try:
content = log_queue.get_nowait()
async with aiofiles.open(report_file_path, "a", encoding="utf-8") as file:
await file.write(f"{content}\n")
log_queue.task_done()
except queue.Empty:
await asyncio.sleep(0.01)
================================================
FILE: zsim/sim_progress/ScheduledEvent/CalAnomaly.py
================================================
from typing import TYPE_CHECKING, Literal
import numpy as np
from zsim.define import ELEMENT_TYPE_MAPPING as ETM
from zsim.define import ElementType
from zsim.sim_progress.anomaly_bar import AnomalyBar
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import (
DirgeOfDestinyAnomaly as Abloom,
)
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import (
Disorder,
PolarityDisorder,
)
from zsim.sim_progress.Character.character import Character
from zsim.sim_progress.Character.Yanagi import Yanagi
from zsim.sim_progress.Enemy import Enemy
from zsim.sim_progress.Report import report_to_log
from .Calculator import Calculator as Cal
from .Calculator import MultiplierData as MulData
if TYPE_CHECKING:
from zsim.sim_progress.Buff import Buff
from zsim.sim_progress.Character import Character
from zsim.simulator.simulator_class import Simulator
class CalAnomaly:
def __init__(
self,
anomaly_obj: AnomalyBar,
enemy_obj: Enemy,
dynamic_buff: dict[str, list["Buff"]],
sim_instance: "Simulator",
):
"""
Schedule 节点对于异常伤害的分支逻辑，用于计算异常伤害
调用方法 cal_anomaly_dmg() 输出.伤害期望
异常伤害快照以 array 形式储存，顺序为：
[基础伤害区、增伤区、异常精通区、等级、异常增伤区、异常暴击区、穿透率、穿透值、抗性穿透]
"""
self.sim_instance = sim_instance
self.enemy_obj = enemy_obj
self.anomaly_obj: AnomalyBar = anomaly_obj
if not self.anomaly_obj.settled:
raise ValueError(
f"即将被计算的 {ETM[self.anomaly_obj.element_type]} 异常条对象尚未结算快照，请检查前置业务逻辑"
)
self.dynamic_buff = dynamic_buff
snapshot: tuple[ElementType, np.ndarray] = (
self.anomaly_obj.element_type,
self.anomaly_obj.current_ndarray,
)
self.element_type: ElementType = snapshot[0]
# self.dmg_sp 以 array 形式储存，顺序为：基础伤害区、增伤区、异常精通区、等级、异常增伤区、异常暴击区、穿透率、穿透值、抗性穿透、冲击力、失衡值增幅
self.dmg_sp: np.ndarray = snapshot[1]
assert self.dmg_sp.shape == (1, 11), (
f"tick: {self.sim_instance.tick} 异常伤害快照形状错误，期望(1, 11)，实际{self.dmg_sp}\n"
f"其他信息：名字：{type(self.anomaly_obj).__name__}\n"
f"属性：{self.anomaly_obj.element_type}\n"
f"是否是紊乱：{self.anomaly_obj.is_disorder}\n"
f"是否已经被结算：{self.anomaly_obj.settled}"
)
if anomaly_obj.activated_by is None:
print(
f"【CalAnomaly Warnning】:检测到异常实例(属性类型：{anomaly_obj.element_type}）的激活源为空，改异常实例将无法享受Buff加成。"
)
raise NotImplementedError
else:
char_obj: "Character | None" = anomaly_obj.activated_by.skill.char_obj
# 根据动态buff读取怪物面板
self.data: MulData = MulData(
enemy_obj=self.enemy_obj,
dynamic_buff=self.dynamic_buff,
judge_node=anomaly_obj,
character_obj=char_obj,
)
# 虚拟角色等级
v_char_level: int = int(
np.floor(self.dmg_sp[0, 3] + 0.0000001)
) # 加一个极小的数避免精度向下丢失导致的误差
self.v_char_level = v_char_level
# 等级系数
k_level = self.cal_k_level(v_char_level)
# 激活型暴击区（目前仅简的核心被动）
active_crit: float = self.cal_active_crit(self.data)
# 防御区
def_mul: np.float64 = self.cal_def_mul(self.data, v_char_level)
# 抗性区
res_mul: float = Cal.RegularMul.cal_res_mul(
self.data,
element_type=self.element_type,
snapshot_res_pen=self.dmg_sp[0, 8],
)
# 减易伤区
vulnerability_mul: float = Cal.RegularMul.cal_dmg_vulnerability(
self.data, element_type=self.element_type
)
# 失衡易伤区
stun_vulnerability: float = Cal.RegularMul.cal_stun_vulnerability(self.data)
# 特殊乘区
special_mul: float = Cal.RegularMul.cal_special_mul(self.data)
imp_mul = self.dmg_sp[0, 9]
stun_mul = self.dmg_sp[0, 10]
self.final_multipliers: np.ndarray = self.set_final_multipliers(
k_level,
active_crit,
def_mul,
res_mul,
vulnerability_mul,
stun_vulnerability,
special_mul,
imp_mul,
stun_mul,
)
@staticmethod
def cal_k_level(v_char_level: int) -> np.float64:
"""等级区 = trunc(1+ 1/59* (等级 - 1), 4)"""
# 定义域检查
if v_char_level < 0:
report_to_log(f"角色等级{v_char_level}过低，将被设置为0")
v_char_level = 0
elif v_char_level > 60:
report_to_log(f"角色等级{v_char_level}过高，将被设置为60")
v_char_level = 60
# 查表
# fmt: off
values: list[float] = [
0, 1.0000, 1.0169, 1.0338, 1.0508, 1.0677, 1.0847, 1.1016, 1.1186, 1.1355, 1.1525,
1.1694, 1.1864, 1.2033, 1.2203, 1.2372, 1.2542, 1.2711, 1.2881, 1.3050, 1.3220,
1.3389, 1.3559, 1.3728, 1.3898, 1.4067, 1.4237, 1.4406, 1.4576, 1.4745, 1.4915,
1.5084, 1.5254, 1.5423, 1.5593, 1.5762, 1.5932, 1.6101, 1.6271, 1.6440, 1.6610,
1.6779, 1.6949, 1.7118, 1.7288, 1.7457, 1.7627, 1.7796, 1.7966, 1.8135, 1.8305,
1.8474, 1.8644, 1.8813, 1.8983, 1.9152, 1.9322, 1.9491, 1.9661, 1.9830, 2.0000
]
# fmt: on
return np.float64(values[v_char_level])
def cal_active_crit(self, data: MulData) -> float:
"""激活型异常暴击区
目前仅简的核心被动
"""
if self.element_type == 0:
crit_rate = data.dynamic.strike_crit_rate_increase
crit_dmg = data.dynamic.strike_crit_dmg_increase
return 1 + crit_rate * crit_dmg
else:
return 1
def cal_def_mul(self, data: MulData, v_char_level) -> np.float64:
"""防御区 = 攻击方等级基数 / (受击方有效防御 + 攻击方等级基数)"""
# 攻击方等级系数
k_attacker: int = Cal.RegularMul.cal_k_attacker(v_char_level)
# 计算属性/类型的穿透
if self.element_type == 0:
# 穿透率
addon_pen_ratio = float(self.dmg_sp[0, 6]) + self.data.dynamic.strike_ignore_defense
# 受击方有效防御
else:
addon_pen_ratio = float(self.dmg_sp[0, 6])
# 受击方有效防御
recipient_def: float = Cal.RegularMul.cal_recipient_def(
data,
Cal.RegularMul.cal_pen_ratio(data),
addon_pen_ratio=addon_pen_ratio,
addon_pen_numeric=float(self.dmg_sp[0, 7]),
)
# 计算防御区
defense_mul = k_attacker / (recipient_def + k_attacker)
return np.float64(defense_mul)
def set_final_multipliers(
self,
k_level,
active_crit,
def_mul,
res_mul,
vulnerability_mul,
stun_vulnerability,
special_mul,
imp_mul,
stun_mul,
) -> np.ndarray:
"""将计算结果写入 self.final_multipliers"""
# self.dmg_sp 以 array 形式储存，顺序为：基础伤害区、增伤区、异常精通区、等级、异常增伤区、异常暴击区、穿透率、穿透值、抗性穿透、冲击力、失衡值增幅
base_dmg = self.dmg_sp[0, 0]
dmg_bonus = self.dmg_sp[0, 1]
am_mul = self.dmg_sp[0, 2]
anomaly_bonus = self.dmg_sp[0, 4]
active_crit = active_crit
# 将所有乘数放入一个数组
results = np.array(
[
base_dmg,
dmg_bonus,
am_mul,
k_level,
anomaly_bonus,
active_crit,
def_mul,
res_mul,
vulnerability_mul,
imp_mul,
stun_mul,
stun_vulnerability,
special_mul,
],
dtype=np.float64,
)
return results
def cal_anomaly_dmg(self) -> np.float64:
"""计算异常伤害期望"""
"""
在v0.3.5a1中，由于爱丽丝的核心被动Dot会以固定比例造成属性异常伤害，
所以我们为属性异常伤害期望计算添加了缩放比例的乘算逻辑
"""
return np.float64(
np.prod(self.final_multipliers)
/ (self.dmg_sp[0, 9] * self.dmg_sp[0, 10])
* self.anomaly_obj.scaling_factor
)
class CalDisorder(CalAnomaly):
def __init__(
self,
disorder_obj: Disorder,
enemy_obj: Enemy,
dynamic_buff: dict[str, list["Buff"]],
sim_instance: "Simulator",
):
"""
异常伤害快照以 array 形式储存，顺序为：
[基础伤害区、增伤区、异常精通区、等级、异常增伤区、异常暴击区、穿透率、穿透值、抗性穿透]
"""
super().__init__(disorder_obj, enemy_obj, dynamic_buff, sim_instance=sim_instance)
self.final_multipliers[0] = self.cal_disorder_base_dmg(
np.float64(self.final_multipliers[0])
)
self.final_multipliers[4] = self.cal_disorder_extra_mul()
def cal_disorder_base_dmg(self, base_mul: np.float64) -> np.float64:
"""
计算紊乱的基础伤害
紊乱基础伤害 = (各属性异常剩余倍率 + 各属性紊乱基础倍率) * (1 + 紊乱基础倍率增幅)
"""
t_s = np.float64(self.anomaly_obj.remaining_tick() / 60)
disorder_base_dmg: np.float64
# 计算紊乱基础倍率增幅
disorder_basic_mul_map = self.data.dynamic.disorder_basic_mul_map
disorder_base_ratio_increase = (
disorder_basic_mul_map[self.element_type] + disorder_basic_mul_map["all"]
)
# 计算紊乱基础伤害
match self.element_type:
case 0: # 强击紊乱
_atk = base_mul / 7.13
_ratio = np.floor(t_s) * 0.075 + 4.5 + disorder_base_ratio_increase
case 1: # 灼烧紊乱
_atk = base_mul / 0.5
_ratio = np.floor(t_s / 0.5) * 0.5 + 4.5 + disorder_base_ratio_increase
case 2: # 霜寒紊乱
_atk = base_mul / 5
_ratio = np.floor(t_s) * 0.075 + 4.5 + disorder_base_ratio_increase
case 3: # 感电紊乱
_atk = base_mul / 1.25
_ratio = np.floor(t_s) * 1.25 + 4.5 + disorder_base_ratio_increase
case 4: # 侵蚀紊乱
_atk = base_mul / 0.625
_ratio = np.floor(t_s / 0.5) * 0.625 + 4.5 + disorder_base_ratio_increase
case 5: # 烈霜紊乱
_atk = base_mul / 5
_ratio = np.floor(t_s) * 0.75 + 6 + disorder_base_ratio_increase
case 6: # 玄墨侵蚀紊乱
_atk = base_mul / 0.625
_ratio = np.floor(t_s / 0.5) * 0.625 + 4.5 + disorder_base_ratio_increase
case _:
raise AssertionError(f"Invalid Element Type {self.element_type}")
disorder_base_dmg = _atk * _ratio
# from zsim.define import ELEMENT_TYPE_MAPPING as ETM
# print(f"111111，计算紊乱！{ETM[self.element_type]}属性的紊乱，攻击力为：{_atk:.2f}，倍率为：{_ratio:.2f}, 紊乱倍率加成为：{disorder_base_ratio_increase}")
return np.float64(disorder_base_dmg)
def cal_disorder_extra_mul(self) -> np.float64:
"""
计算紊乱的异常额外增伤区，即紊乱的异常增伤区。
异常额外增伤区 = 1 + 对应属性异常额外增伤
紊乱的额外增伤本身只有一个词条：紊乱额外伤害增幅（disorder_dmg_mul），该词条本身是对所有紊乱通用的，
所以若是要实现“X属性紊乱伤害增幅”，则必须通过buff label的"specified_disorder_element_type"加以限制。
"""
map: dict[ElementType | Literal["all", -1], float] = self.data.dynamic.ano_extra_bonus
return np.float64(1 + map[-1])
def cal_disorder_stun(self) -> np.float64:
imp = self.final_multipliers[9]
stun_ratio = 2
stun_res = Cal.StunMul.cal_stun_res(self.data, self.element_type)
stun_bonus = self.final_multipliers[10]
stun_received = Cal.StunMul.cal_stun_received(self.data)
k_level_for_stun = 1 + self.v_char_level * 0.0075
return np.float64(
np.prod([imp, stun_ratio, stun_res, stun_bonus, stun_received, k_level_for_stun])
)
class CalPolarityDisorder(CalDisorder):
def __init__(
self,
disorder_obj: PolarityDisorder,
enemy_obj: Enemy,
dynamic_buff: dict[str, list["Buff"]],
sim_instance: "Simulator",
):
super().__init__(disorder_obj, enemy_obj, dynamic_buff, sim_instance=sim_instance)
yanagi_obj = self.__find_yanagi()
yanagi_mul = MulData(
enemy_obj=enemy_obj, dynamic_buff=dynamic_buff, character_obj=yanagi_obj
)
ap = Cal.AnomalyMul.cal_ap(yanagi_mul)
self.final_multipliers[0] = (
self.final_multipliers[0] * disorder_obj.polarity_disorder_ratio
) + (ap * disorder_obj.additional_dmg_ap_ratio)
def __find_yanagi(self) -> Yanagi | None:
yanagi_obj: Character | None = self.sim_instance.char_data.char_obj_dict.get("柳", None)
if yanagi_obj is None or not isinstance(yanagi_obj, Yanagi):
raise AssertionError("没柳你哪来的极性紊乱")
return yanagi_obj
class CalAbloom(CalAnomaly):
def __init__(
self,
abloom_obj: Abloom,
enemy_obj: Enemy,
dynamic_buff: dict[str, list["Buff"]],
sim_instance: "Simulator",
):
super().__init__(abloom_obj, enemy_obj, dynamic_buff, sim_instance=sim_instance)
self.final_multipliers[0] *= abloom_obj.anomaly_dmg_ratio
================================================
FILE: zsim/sim_progress/ScheduledEvent/Calculator.py
================================================
import json
from functools import lru_cache
from typing import Any, Literal
import numpy as np
from zsim.define import CHECK_SKILL_MUL, CHECK_SKILL_MUL_TAG, INVALID_ELEMENT_ERROR, ElementType
from zsim.sim_progress.anomaly_bar.AnomalyBarClass import AnomalyBar
from zsim.sim_progress.Character import Character
from zsim.sim_progress.data_struct import cal_buff_total_bonus
from zsim.sim_progress.Enemy import Enemy
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Report import report_to_log
from .constants import EventConstants
with open(
file="./zsim/sim_progress/ScheduledEvent/buff_effect_trans.json",
mode="r",
encoding="utf-8-sig",
) as f:
buff_effect_trans: dict = json.load(f)
class MultiplierData:
"""
乘数数据缓存管理类
使用缓存机制来存储和重用乘数计算结果，提高性能。
采用 LRU (Least Recently Used) 缓存策略来自动管理缓存大小。
"""
mul_data_cache: dict[tuple, "MultiplierData"] = {}
MAX_CACHE_SIZE = EventConstants.MAX_CACHE_SIZE
def __new__(
cls,
enemy_obj: Enemy,
dynamic_buff: dict[str, list],
character_obj: Character | None = None,
judge_node: SkillNode | AnomalyBar | None = None,
):
hashable_dynamic_buff = tuple((key, tuple(value)) for key, value in dynamic_buff.items())
enemy_hashable = (
tuple(enemy_obj.dynamic.dynamic_debuff_list),
tuple(enemy_obj.dynamic.dynamic_dot_list),
)
node_id = id(judge_node)
if isinstance(judge_node, AnomalyBar):
node_id = judge_node.UUID
# 使用更稳定的唯一标识符，避免垃圾回收后的问题
character_id = (
getattr(character_obj, "UUID", None)
or getattr(character_obj, "CID", None)
or f"{character_obj.__class__.__name__}_{id(character_obj)}"
)
cache_key = tuple((enemy_hashable, hashable_dynamic_buff, character_id, node_id))
if cache_key in cls.mul_data_cache:
return cls.mul_data_cache[cache_key]
else:
instance = super().__new__(cls)
if len(cls.mul_data_cache) >= cls.MAX_CACHE_SIZE:
cls.mul_data_cache.popitem()
cls.mul_data_cache[cache_key] = instance
return instance
def __init__(
self,
enemy_obj: Enemy,
dynamic_buff: dict | None = None,
character_obj: Character | None = None,
judge_node: SkillNode | AnomalyBar | None = None,
):
"""
初始化乘数数据实例
Args:
enemy_obj: 敌人对象
dynamic_buff: 动态buff字典
character_obj: 角色对象
judge_node: 判断节点（技能节点或异常条）
"""
if dynamic_buff is None:
dynamic_buff = {}
if not hasattr(self, "char_name"):
self.judge_node: SkillNode | AnomalyBar | None = judge_node
self.enemy_instance = enemy_obj
if character_obj is None:
self.char_name = None
self.char_level = None
self.cid = None
self.char_instance = None
else:
self.char_name = character_obj.NAME
self.char_level = character_obj.level
self.cid = character_obj.CID
self.char_instance = character_obj
# 获取角色局外面板数据
static_statement: Character.Statement | None = getattr(character_obj, "statement", None)
self.static = self.StaticStatement(static_statement)
# 获取敌人数据
self.enemy_obj = enemy_obj
# 获取buff动态加成
dynamic_statement: dict = self.get_buff_bonus(dynamic_buff, self.judge_node)
self.dynamic = self.DynamicStatement(dynamic_statement)
def get_buff_bonus(self, dynamic_buff: dict, node: SkillNode | AnomalyBar | None) -> dict:
"""
获取buff加成数据
Args:
dynamic_buff: 动态buff字典
node: 判断节点
Returns:
dict: 包含所有buff加成的字典
"""
if self.char_name is None:
char_buff: list = []
else:
try:
char_buff = dynamic_buff[self.char_name]
except KeyError:
char_buff = []
report_to_log(f"[WARNING] 动态Buff列表内没有角色 {self.char_name}", level=4)
try:
enemy_buff: list = self.enemy_obj.dynamic.dynamic_debuff_list
except AttributeError:
report_to_log("[WARNING] self.enemy_obj 中找不到动态buff列表", level=4)
try:
enemy_buff = dynamic_buff["enemy"]
except KeyError:
report_to_log("[WARNING] dynamic_buff 中依然找不到动态buff列表", level=4)
enemy_buff = []
enabled_buff: tuple = tuple(char_buff + enemy_buff)
try:
dynamic_statement: dict = cal_buff_total_bonus(
enabled_buff=enabled_buff,
judge_obj=node,
sim_instance=self.enemy_obj.sim_instance,
char_name=self.char_name,
)
except TypeError as err:
raise TypeError(
f"参数错误！enabled_buff为{type(enabled_buff)}，node为{type(node)}"
) from err
return dynamic_statement
class StaticStatement:
_instance_cache: dict[tuple | None, Any] = {}
_max_cache_size = 128
def __new__(cls, static_statement: Character.Statement | None):
if static_statement is None:
cache_key = None
else:
cache_key = tuple(sorted(static_statement.statement.items()))
if cache_key in cls._instance_cache:
return cls._instance_cache[cache_key]
else:
instance = super().__new__(cls)
if len(cls._instance_cache) >= cls._max_cache_size:
cls._instance_cache.popitem()
cls._instance_cache[cache_key] = instance
return instance
def __init__(self, static_statement: Character.Statement | None):
"""将角色面板抄下来！！！！！如果没有角色传入，那就生成屎！！！"""
self.atk: float = 0.0
self.hp: float = 0.0
self.defense: float = 0.0
self.imp: float = 0.0
self.ap: float = 0.0
self.am: float = 0.0
self.crit_rate: float = 0.0
self.crit_damage: float = 0.0
self.sp_regen: float = 0.0
self.sp_get_ratio: float = 0.0
self.sp_limit: float = 0.0
self.pen_ratio: float = 0.0
self.pen_numeric: float = 0.0
self.phy_dmg_bonus: float = 0.0
self.ice_dmg_bonus: float = 0.0
self.fire_dmg_bonus: float = 0.0
self.ether_dmg_bonus: float = 0.0
self.electric_dmg_bonus: float = 0.0
attribute_map = {
"atk": "ATK",
"hp": "HP",
"defense": "DEF",
"imp": "IMP",
"ap": "AP",
"am": "AM",
"crit_rate": "CRIT_rate",
"crit_damage": "CRIT_damage",
"sp_regen": "sp_regen",
"sp_get_ratio": "sp_get_ratio",
"sp_limit": "sp_limit",
"pen_ratio": "PEN_ratio",
"pen_numeric": "PEN_numeric",
"phy_dmg_bonus": "PHY_DMG_bonus",
"ice_dmg_bonus": "ICE_DMG_bonus",
"fire_dmg_bonus": "FIRE_DMG_bonus",
"ether_dmg_bonus": "ETHER_DMG_bonus",
"electric_dmg_bonus": "ELECTRIC_DMG_bonus",
}
if static_statement is None:
pass
else:
for attr, static_attr in attribute_map.items():
setattr(self, attr, getattr(static_statement, static_attr, 0.0))
class DynamicStatement:
def __init__(self, dynamic_statement):
"""
buff动态加成的初始化蟑螂桶，这一百多行不是屎山，是为了IDE能认识这些傻逼玩意
"""
self.buff_name: float = 0.0
self.hp: float = 0.0
self.atk: float = 0.0
self.defense: float = 0.0
self.imp: float = 0.0
self.crit_rate: float = 0.0
self.crit_dmg: float = 0.0
self.anomaly_proficiency: float = 0.0
self.anomaly_mastery: float = 0.0
self.pen_ratio: float = 0.0
self.pen_numeric: float = 0.0
self.sp_regen: float = 0.0
self.sp_get_ratio: float = 0.0
self.sp_limit: float = 0.0
self.phy_dmg_bonus: float = 0.0
self.fire_dmg_bonus: float = 0.0
self.ice_dmg_bonus: float = 0.0
self.electric_dmg_bonus: float = 0.0
self.ether_dmg_bonus: float = 0.0
self.field_hp_percentage: float = 0.0
self.field_atk_percentage: float = 0.0
self.field_def_percentage: float = 0.0
self.field_imp_percentage: float = 0.0
self.field_crit_rate: float = 0.0
self.field_crit_dmg: float = 0.0
self.field_anomaly_proficiency: float = 0.0
self.field_anomaly_mastery: float = 0.0
self.field_pen_ratio: float = 0.0
self.field_pen_numeric: float = 0.0
self.field_sp_regen: float = 0.0
self.field_sp_get_ratio: float = 0.0
self.field_sp_limit: float = 0.0
self.extra_damage_ratio: float = 0.0 # 基础伤害倍率
self.decibel_get_ratio: float = 0.0 # 喧响获得效率
self.phy_crit_dmg_bonus: float = 0.0
self.fire_crit_dmg_bonus: float = 0.0
self.ice_crit_dmg_bonus: float = 0.0
self.electric_crit_dmg_bonus: float = 0.0
self.ether_crit_dmg_bonus: float = 0.0
self.phy_crit_rate_bonus: float = 0.0
self.fire_crit_rate_bonus: float = 0.0
self.ice_crit_rate_bonus: float = 0.0
self.electric_crit_rate_bonus: float = 0.0
self.ether_crit_rate_bonus: float = 0.0
self.attack_type_dmg_bonus: float = 0.0
self.normal_attack_dmg_bonus: float = 0.0
self.special_skill_dmg_bonus: float = 0.0
self.ex_special_skill_dmg_bonus: float = 0.0
self.dash_attack_dmg_bonus: float = 0.0
self.counter_attack_dmg_bonus: float = 0.0
self.qte_dmg_bonus: float = 0.0
self.ultimate_dmg_bonus: float = 0.0
self.quick_aid_dmg_bonus: float = 0.0
self.defensive_aid_dmg_bonus: float = 0.0
self.assault_aid_dmg_bonus: float = 0.0
self.anomaly_dmg_bonus: float = 0.0
self.all_dmg_bonus: float = 0.0
self.percentage_def_reduction: float = 0.0
self.def_reduction: float = 0.0
self.all_dmg_res_decrease: float = 0.0
self.physical_dmg_res_decrease: float = 0.0
self.fire_dmg_res_decrease: float = 0.0
self.ice_dmg_res_decrease: float = 0.0
self.electric_dmg_res_decrease: float = 0.0
self.ether_dmg_res_decrease: float = 0.0
self.all_res_pen_increase: float = 0.0
self.physical_res_pen_increase: float = 0.0
self.fire_res_pen_increase: float = 0.0
self.ice_res_pen_increase: float = 0.0
self.electric_res_pen_increase: float = 0.0
self.ether_res_pen_increase: float = 0.0
self.all_anomaly_res_decrease: float = 0.0
self.physical_anomaly_res_decrease: float = 0.0
self.fire_anomaly_res_decrease: float = 0.0
self.ice_anomaly_res_decrease: float = 0.0
self.electric_anomaly_res_decrease: float = 0.0
self.ether_anomaly_res_decrease: float = 0.0
self.received_crit_dmg_bonus: float = 0.0
self.crit_rate_received_increase: float = 0.0
self.physical_vulnerability: float = 0.0
self.fire_vulnerability: float = 0.0
self.ice_vulnerability: float = 0.0
self.electric_vulnerability: float = 0.0
self.ether_vulnerability: float = 0.0
self.anomaly_vulnerability: float = 0.0
self.all_vulnerability: float = 0.0
self.stun_res: float = 0.0
self.stun_bonus: float = 0.0
self.received_stun_increase: float = 0.0
self.stun_vulnerability_increase: float = 0.0
self.stun_vulnerability_increase_all_time: float = 0.0
self.normal_attack_stun_bonus: float = 0.0
self.special_skill_stun_bonus: float = 0.0
self.ex_special_skill_stun_bonus: float = 0.0
self.dash_attack_stun_bonus: float = 0.0
self.counter_attack_stun_bonus: float = 0.0
self.qte_stun_bonus: float = 0.0
self.ultimate_stun_bonus: float = 0.0
self.quick_aid_stun_bonus: float = 0.0
self.defensive_aid_stun_bonus: float = 0.0
self.assault_aid_stun_bonus: float = 0.0
self.physical_anomaly_buildup_bonus: float = 0.0
self.fire_anomaly_buildup_bonus: float = 0.0
self.ice_anomaly_buildup_bonus: float = 0.0
self.electric_anomaly_buildup_bonus: float = 0.0
self.ether_anomaly_buildup_bonus: float = 0.0
self.frost_anomaly_buildup_bonus: float = 0.0
self.all_anomaly_buildup_bonus: float = 0.0
self.normal_attack_anomaly_buildup_bonus: float = 0.0
self.special_skill_anomaly_buildup_bonus: float = 0.0
self.ex_special_skill_anomaly_buildup_bonus: float = 0.0
self.dash_attack_anomaly_buildup_bonus: float = 0.0
self.counter_attack_anomaly_buildup_bonus: float = 0.0
self.qte_anomaly_buildup_bonus: float = 0.0
self.ultimate_anomaly_buildup_bonus: float = 0.0
self.quick_aid_anomaly_buildup_bonus: float = 0.0
self.defensive_aid_anomaly_buildup_bonus: float = 0.0
self.assault_aid_anomaly_buildup_bonus: float = 0.0
self.assault_dmg_mul: float = 0.0
self.burn_dmg_mul: float = 0.0
self.freeze_dmg_mul: float = 0.0
self.shock_dmg_mul: float = 0.0
self.chaos_dmg_mul: float = 0.0
self.disorder_dmg_mul: float = 0.0
self.all_anomaly_dmg_mul: float = 0.0
self.special_multiplier_zone: float = 0.0
self.stun_tick_increase: int = 0
self.base_dmg_increase: float = 0.0
self.base_dmg_increase_percentage: float = 0.0
self.aftershock_attack_dmg_bonus: float = 0.0
self.aftershock_attack_crit_dmg_bonus: float = 0.0
self.aftershock_attack_stun_bonus: float = 0.0
self.assault_time_increase: float = 0.0
self.assault_time_increase_percentage: float = 0.0
self.burn_time_increase: float = 0.0
self.burn_time_increase_percentage: float = 0.0
self.shock_time_increase: float = 0.0
self.shock_time_increase_percentage: float = 0.0
self.corruption_time_increase: float = 0.0
self.corruption_time_increase_percentage: float = 0.0
self.frostbite_time_increase: float = 0.0
self.frostbite_time_increase_percentage: float = 0.0
self.frost_frostbite_time_increase: float = 0.0
self.frost_frostbite_time_increase_percentage: float = 0.0
self.all_anomaly_time_increase: float = 0.0
self.all_anomaly_time_increase_percentage: float = 0.0
self.strike_crit_rate_increase: float = 0.0
self.strike_crit_dmg_increase: float = 0.0
self.strike_ignore_defense: float = 0.0
# 异常其他属性
self.strike_crit_rate_increase: float = 0.0
self.strike_crit_dmg_increase: float = 0.0
self.strike_ignore_defense: float = 0.0
self.all_disorder_basic_mul: float = 0.0
self.strike_disorder_basic_mul: float = 0.0
self.burn_disorder_basic_mul: float = 0.0
self.frostbite_disorder_basic_mul: float = 0.0
self.shock_disorder_basic_mul: float = 0.0
self.chaos_disorder_basic_mul: float = 0.0
self.sheer_atk: float = 0.0 # 固定贯穿力增幅
self.field_sheer_atk_percentage: float = 0.0 # 局内百分比贯穿力增幅
self.sheer_dmg_bonus: float = 0.0 # 贯穿伤害增加
self.__read_dynamic_statement(dynamic_statement)
"""在更新完全部Buff效果后，再组成字典（提前组成字典会导致字典内容和后置的赋值脱钩）"""
self.ano_extra_bonus: dict[ElementType | Literal["all", -1], float] = {
0: self.assault_dmg_mul,
1: self.burn_dmg_mul,
2: self.freeze_dmg_mul,
3: self.shock_dmg_mul,
4: self.chaos_dmg_mul,
5: self.freeze_dmg_mul,
-1: self.disorder_dmg_mul,
"all": self.all_anomaly_dmg_mul,
}
self.anomaly_time_increase: dict[ElementType | Literal["all"], float] = {
0: self.assault_time_increase,
1: self.burn_time_increase,
2: self.shock_time_increase,
3: self.frostbite_time_increase,
4: self.corruption_time_increase,
5: self.frost_frostbite_time_increase,
"all": self.all_anomaly_time_increase,
}
self.anomaly_time_increase_percentage: dict[ElementType | Literal["all"], float] = {
0: self.assault_time_increase_percentage,
1: self.burn_time_increase_percentage,
2: self.shock_time_increase_percentage,
3: self.frostbite_time_increase_percentage,
4: self.corruption_time_increase_percentage,
5: self.frost_frostbite_time_increase_percentage,
"all": self.all_anomaly_time_increase_percentage,
}
self.disorder_basic_mul_map: dict[ElementType | Literal["all"], float] = {
0: self.strike_disorder_basic_mul,
1: self.burn_disorder_basic_mul,
2: self.frostbite_disorder_basic_mul,
3: self.shock_disorder_basic_mul,
4: self.chaos_disorder_basic_mul,
5: self.frostbite_disorder_basic_mul,
6: self.chaos_disorder_basic_mul,
"all": self.all_disorder_basic_mul,
}
def __read_dynamic_statement(self, dynamic_statement: dict) -> None:
"""使用翻译json初始化动态面板"""
# 打开buff_effect_trans.json
# 确保所有的属性都有默认值
# for value in buff_effect_trans.values():
# if not hasattr(self, value):
# setattr(self, value, 0.0)
# 遍历dynamic_statement，根据json翻译，设置对应的属性值
for CNkey, value in dynamic_statement.items():
if CNkey in buff_effect_trans:
attr_name = buff_effect_trans[CNkey]
setattr(self, attr_name, getattr(self, attr_name) + value)
else:
raise KeyError(f"Invalid buff multiplier key: {CNkey}")
class Calculator:
def __init__(
self,
skill_node: SkillNode,
character_obj: Character,
enemy_obj: Enemy,
dynamic_buff: dict | None = None,
):
"""
Calculator 是 Schedule 阶段获得 SkillNode 后的计算处理逻辑
当计划事件读取到 SkillNode 时，Calculator 会根据目前的角色的面板、enemy 对象、角色的动态buff，
计算出角色的直伤、异常、失衡的各乘区，并根据需求计算出输出、异常值、异常快照、失衡值
"""
if dynamic_buff is None:
dynamic_buff = {}
if not isinstance(skill_node, SkillNode):
raise ValueError("错误的参数类型，应该为SkillNode")
if not isinstance(character_obj, Character):
raise ValueError("错误的参数类型，应该为Character")
if not isinstance(enemy_obj, Enemy):
raise ValueError("错误的参数类型，应该为Enemy")
if not isinstance(dynamic_buff, dict):
raise ValueError("错误的参数类型，应该为dict")
# 创建MultiplierData对象，用于计算各种战斗中的乘区数据
data = MultiplierData(enemy_obj, dynamic_buff, character_obj, skill_node)
# 初始化角色名称和角色ID
self.char_name: str | None = data.char_name
self.cid: int | None = data.cid
self.skill_node = skill_node
assert isinstance(data.judge_node, SkillNode)
self.element_type = data.judge_node.element_type
self.skill_tag = data.judge_node.skill_tag
# 初始化各种乘区
self.regular_multipliers = self.RegularMul(data)
self.anomaly_multipliers = self.AnomalyMul(data)
self.stun_multipliers = self.StunMul(data)
# 处理失衡时间增加
self.update_stun_tick(enemy_obj, data)
class RegularMul:
"""
负责计算与储存与常规直伤有关的属性
常规直伤 = 基础伤害区 * 增伤区 * 暴击区 * 防御区 * 抗性区 * 减易伤区 * 失衡易伤区 * 特殊乘区
"""
def __init__(self, data: MultiplierData):
self.base_dmg = self.cal_base_dmg(data)
self.dmg_bonus = self.cal_dmg_bonus(data)
self.crit_rate = self.cal_crit_rate(data)
self.crit_dmg = self.cal_crit_dmg(data)
self.crit_expect = self.cal_crit_expect(data)
self.defense_mul = self.cal_defense_mul(data)
self.res_mul = self.cal_res_mul(data)
self.dmg_vulnerability = self.cal_dmg_vulnerability(data)
self.stun_vulnerability = self.cal_stun_vulnerability(data)
self.special_multiplier_zone = self.cal_special_mul(data)
self.sheer_dmg_bonus = self.cal_sheer_dmg_bonus(data)
# 常规伤害
self.regular_dmg_multipliers = {
"基础伤害区": self.base_dmg,
"增伤区": self.dmg_bonus,
"暴击率": self.crit_rate,
"暴击伤害": self.crit_dmg,
"暴击期望": self.crit_expect,
"防御区": self.defense_mul,
"抗性区": self.res_mul,
"减易伤区": self.dmg_vulnerability,
"失衡易伤区": self.stun_vulnerability,
"特殊倍率区": self.special_multiplier_zone,
"贯穿伤害区": self.sheer_dmg_bonus,
}
def get_array_expect(self) -> np.ndarray:
array_expect: np.ndarray = np.array(
[
self.base_dmg,
self.dmg_bonus,
self.crit_expect,
self.defense_mul,
self.res_mul,
self.dmg_vulnerability,
self.stun_vulnerability,
self.special_multiplier_zone,
self.sheer_dmg_bonus,
],
dtype=np.float64,
)
return array_expect
def get_array_crit(self) -> np.ndarray:
when_crit_mul = 1 + self.crit_dmg
array_crit: np.ndarray = np.array(
[
self.base_dmg,
self.dmg_bonus,
when_crit_mul,
self.defense_mul,
self.res_mul,
self.dmg_vulnerability,
self.stun_vulnerability,
self.special_multiplier_zone,
self.sheer_dmg_bonus,
],
dtype=np.float64,
)
return array_crit
def get_array_not_crit(self) -> np.ndarray:
array_no_crit: np.ndarray = np.array(
[
self.base_dmg,
self.dmg_bonus,
1,
self.defense_mul,
self.res_mul,
self.dmg_vulnerability,
self.stun_vulnerability,
self.special_multiplier_zone,
self.sheer_dmg_bonus,
],
dtype=np.float64,
)
return array_no_crit
def cal_base_dmg(self, data: MultiplierData) -> float:
"""
基础伤害区 = 伤害倍率 * 对应属性
如非特殊注明，代理人技能的伤害倍率都是基于自身攻击力的，在代理人的技能页面可以轻易查阅技能的伤害倍率，
玩家也可以在战斗中于暂停菜单中看到技能的伤害倍率。
而代理人的攻击力也可以在代理人页面或战斗中的暂停菜单中查阅，当然考虑到战斗中可能存在的各种Buff，
实时的伤害计算请关注战斗中实际的攻击力数值。
"""
assert isinstance(data.judge_node, SkillNode), "非法的调用，没有获取到skill node"
# 伤害倍率 = 技能伤害倍率 / 攻击次数
dmg_ratio = data.judge_node.skill.damage_ratio / data.judge_node.hit_times
# 获取伤害对应属性
base_attr = data.judge_node.skill.diff_multiplier
# 属性为攻击力
attr = self.cal_base_attr(base_attr, data)
base_dmg = ((dmg_ratio + data.dynamic.extra_damage_ratio) * attr) * (
1 + data.dynamic.base_dmg_increase_percentage
) + data.dynamic.base_dmg_increase
# if data.judge_node.char_name == "雅":
# print(f"雅的基础乘区为：{dmg_ratio:.2f}, 基础攻击力{data.static.atk:.2f} 局内百分比 {data.dynamic.field_atk_percentage:.2f}固定攻击力{data.dynamic.atk:.2f}")
return base_dmg
def cal_base_attr(self, base_attr: int, data: MultiplierData):
"""根据base_attr来计算对应属性的值"""
if base_attr == 0:
# 攻击力 = 局外攻击力 * 局内百分比攻击力 + 局内固定攻击力
attr = data.static.atk * (1 + data.dynamic.field_atk_percentage) + data.dynamic.atk
# 属性为生命值
elif base_attr == 1:
attr = data.static.hp * (1 + data.dynamic.field_hp_percentage) + data.dynamic.hp
# 属性为防御力
elif base_attr == 2:
attr = (
data.static.defense * (1 + data.dynamic.field_def_percentage)
+ data.dynamic.defense
)
# 属性为精通
elif base_attr == 3:
attr = (
data.static.ap * (1 + data.dynamic.field_anomaly_proficiency)
+ data.dynamic.anomaly_proficiency
)
elif base_attr == 4:
assert data.char_instance is not None
# 贯穿力属性的实时计算
if not hasattr(data.char_instance, "sheer_attack_conversion_rate"):
raise AttributeError(
f"{data.char_instance.NAME}作为命破属性代理人，必须拥有贯穿力转化字典！"
)
base_sheer_atk = 0
assert data.char_instance.sheer_attack_conversion_rate is not None
for (
key,
value,
) in data.char_instance.sheer_attack_conversion_rate.items():
if key not in [0, 1, 2, 3]:
raise ValueError(f"无法解析的贯穿力转化率key：{key}")
if value <= 0:
continue
base_sheer_atk += self.cal_base_attr(base_attr=key, data=data) * value
else:
if data.dynamic.field_sheer_atk_percentage != 0:
raise ValueError(
"警告！检测到非0的“局内贯穿力%Buff”，该效果目前还无法处理，请注意检查buff_effect"
)
current_sheer_atk = base_sheer_atk + data.dynamic.sheer_atk
attr = current_sheer_atk
# if data.dynamic.sheer_atk != 0:
# print(f"检测到 {data.char_instance.NAME} 的局内固定贯穿力Buff：{data.dynamic.sheer_atk}, 基础贯穿力：{base_sheer_atk}")
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
return attr
@staticmethod
def cal_dmg_bonus(data: MultiplierData) -> float:
"""
增伤区 = 100% + 属性增伤 + 伤害类型增伤 + 进攻类型增伤 + 全类型增伤
增伤区包含游戏中各种百分比形式的伤害提升/加成，造成伤害降低同样作用于该乘区，理解为负的增伤即可。
属性增伤即针对游戏中5种伤害属性(火(Fire)、电(Electric)、冰(Ice)、物理(Physical)和以太(Ether))的伤害加成。属性增伤常见于驱动盘位的主属性和音擎效果。
伤害类型增伤包括针对于各类技能(如普通攻击，强化特殊技，终结技等)的增伤。常见于音擎效果和鸣徽效果中。
进攻类型增伤即针对于角色进攻类型(斩击(Slash)、打击(Strike)和穿透(Pierce))的增伤。全类型增伤就是未作类型限定的增伤。
"""
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
# 获取属性伤害加成，初始化为1.0
if element_type == 0:
element_dmg_bonus = data.static.phy_dmg_bonus + data.dynamic.phy_dmg_bonus
elif element_type == 1:
element_dmg_bonus = data.static.fire_dmg_bonus + data.dynamic.fire_dmg_bonus
elif element_type == 3:
element_dmg_bonus = data.static.electric_dmg_bonus + data.dynamic.electric_dmg_bonus
elif element_type == 2 or element_type == 5:
element_dmg_bonus = data.static.ice_dmg_bonus + data.dynamic.ice_dmg_bonus
elif element_type in [4, 6]:
element_dmg_bonus = data.static.ether_dmg_bonus + data.dynamic.ether_dmg_bonus
else:
raise ValueError(f"Invalid element type: {element_type}, must be a integer in 0~6")
# 获取指定Tag增伤
trigger_buff_level = data.judge_node.skill.trigger_buff_level
if trigger_buff_level == 0:
trigger_dmg_bonus = data.dynamic.normal_attack_dmg_bonus
elif trigger_buff_level == 1:
trigger_dmg_bonus = data.dynamic.special_skill_dmg_bonus
elif trigger_buff_level == 2:
trigger_dmg_bonus = data.dynamic.ex_special_skill_dmg_bonus
elif trigger_buff_level == 3:
trigger_dmg_bonus = data.dynamic.dash_attack_dmg_bonus
elif trigger_buff_level == 4:
trigger_dmg_bonus = data.dynamic.counter_attack_dmg_bonus
elif trigger_buff_level == 5:
trigger_dmg_bonus = data.dynamic.qte_dmg_bonus
elif trigger_buff_level == 6:
trigger_dmg_bonus = data.dynamic.ultimate_dmg_bonus
elif trigger_buff_level == 7:
trigger_dmg_bonus = data.dynamic.quick_aid_dmg_bonus
elif trigger_buff_level == 8:
trigger_dmg_bonus = data.dynamic.defensive_aid_dmg_bonus
elif trigger_buff_level == 9:
trigger_dmg_bonus = data.dynamic.assault_aid_dmg_bonus
elif trigger_buff_level == 10:
trigger_dmg_bonus = 0
else:
raise AssertionError("Invalid trigger_level")
# 获取指定label增伤
if (
data.judge_node.skill.labels is not None
and data.judge_node.skill.labels.get("aftershock_attack") == 1
):
label_dmg_bonus = data.dynamic.aftershock_attack_dmg_bonus
else:
label_dmg_bonus = 0
dmg_bonus = (
1
+ element_dmg_bonus
+ trigger_dmg_bonus
+ label_dmg_bonus
+ data.dynamic.all_dmg_bonus
)
# if "Cinema_1" in data.judge_node.skill_tag:
# print(element_dmg_bonus, trigger_dmg_bonus, label_dmg_bonus, data.dynamic.all_dmg_bonus)
# if "1291_CorePassive" in data.judge_node.skill_tag:
# print(
# f"元素类增伤：{element_dmg_bonus}, 技能类型增伤：{trigger_dmg_bonus}, 标签增伤：{label_dmg_bonus}, 全类型增伤：{data.dynamic.all_dmg_bonus}",
# )
return dmg_bonus
@staticmethod
def cal_crit_rate(data: MultiplierData) -> float:
"""暴击率 = 面板暴击率 + buff暴击率 + 受暴击概率增加"""
crit_rate = (
data.static.crit_rate
+ data.dynamic.crit_rate
+ data.dynamic.field_crit_rate
+ data.dynamic.crit_rate_received_increase
)
return crit_rate
@staticmethod
def cal_personal_crit_rate(data: MultiplierData) -> float:
"""个人实时暴击率 = 面板暴击率 + buff暴击率"""
crit_rate = (
data.static.crit_rate + data.dynamic.crit_rate + data.dynamic.field_crit_rate
)
return crit_rate
@staticmethod
def cal_crit_dmg(data: MultiplierData) -> float:
"""暴击伤害 = 静态面板暴击伤害 + buff暴击伤害 + 受暴击伤害增加"""
# 获取指定label暴伤
assert isinstance(data.judge_node, SkillNode)
if (
data.judge_node.skill.labels is not None
and data.judge_node.skill.labels.get("aftershock_attack") == 1
):
label_crit_dmg_bonus = data.dynamic.aftershock_attack_crit_dmg_bonus
else:
label_crit_dmg_bonus = 0
buff_crit_dmg_bonus = (
data.dynamic.crit_dmg + data.dynamic.field_crit_dmg + label_crit_dmg_bonus
)
crit_dmg = (
data.static.crit_damage + buff_crit_dmg_bonus + data.dynamic.received_crit_dmg_bonus
)
return min(5, crit_dmg)
def cal_crit_expect(self, data: MultiplierData) -> float:
"""暴击期望 = 1 + 暴击率 * 暴击伤害"""
if (
data.char_instance is not None
and data.char_instance.crit_balancing
and self.crit_rate > 1
):
# 目前不使用溢出补偿
return 1 + min(1, self.crit_rate) * self.crit_dmg
# 配平算法下的暴击溢出补偿，为了解决配平仅能适配静态面板的问题
# return 1 + ((self.crit_rate - 1) * 2 + self.crit_dmg)
else:
return 1 + min(1, self.crit_rate) * self.crit_dmg
@staticmethod
def cal_personal_crit_dmg(data: MultiplierData) -> float:
"""面板暴击伤害 = 静态面板暴击伤害 + buff暴击伤害"""
personal_crit_dmg = (
data.static.crit_damage + data.dynamic.crit_dmg + data.dynamic.field_crit_dmg
)
return personal_crit_dmg
def cal_defense_mul(self, data: MultiplierData) -> float:
"""
防御区 = 攻击方等级基数 / (受击方有效防御 + 攻击方等级基数)
当检测到攻击属性为4时，说明是贯穿伤害，无视防御区，所以直接返回1
受击方有效防御 = 受击方防御 * (1 - 攻击方穿透率%) - 攻击方穿透值 ≥ 0
受击方防御 = (基础防御 * (1 + 战斗外防御%) + 战斗外固定防御) * (1 + 防御加成% - 防御降低%) + 固定防御
"""
assert isinstance(data.judge_node, SkillNode)
base_attr = data.judge_node.skill.diff_multiplier
if base_attr != 4:
attacker_level: int = data.char_level if data.char_level is not None else 1
# 攻击方等级系数
k_attacker = self.cal_k_attacker(attacker_level)
# 穿透率
pen_ratio = self.cal_pen_ratio(data)
# 受击方有效防御
effective_def = self.cal_recipient_def(data, pen_ratio)
# 防御区
defense_mul = k_attacker / (effective_def + k_attacker)
else:
defense_mul = 1
return defense_mul
@staticmethod
def cal_recipient_def(
data: MultiplierData,
pen_ratio: float,
*,
addon_pen_ratio: float = 0.0,
addon_pen_numeric: float = 0.0,
) -> float:
# 受击方防御
recipient_def = (
data.enemy_obj.max_DEF * (1 - data.dynamic.percentage_def_reduction)
- data.dynamic.def_reduction
)
# 穿透值
pen_numeric: float = (
data.static.pen_numeric + data.dynamic.pen_numeric + addon_pen_numeric
)
# 受击方有效防御
effective_def: float = max(
0.0, recipient_def * (1 - pen_ratio - addon_pen_ratio) - pen_numeric
)
return effective_def
@staticmethod
def cal_pen_ratio(data: MultiplierData, *, addon_pen_ratio=0.0):
return data.static.pen_ratio + data.dynamic.pen_ratio + addon_pen_ratio
@staticmethod
def cal_k_attacker(attacker_level: int) -> int:
# 定义域检查
if attacker_level < 0:
report_to_log(f"角色等级{attacker_level}过低，将被设置为0")
attacker_level = 0
elif attacker_level > 60:
report_to_log(f"角色等级{attacker_level}过高，将被设置为60")
attacker_level = 60
# 攻击方等级系数
# fmt: off
values: list[int] = [
0, 50, 54, 58, 62, 66, 71, 76, 82, 88, 94,
100, 107, 114, 121, 129, 137, 145, 153, 162,
172, 181, 191, 201, 211, 222, 233, 245, 258,
268, 281, 293, 306, 319, 333, 347, 362, 377,
393, 409, 421, 436, 452, 469, 485, 502, 519,
537, 556, 573, 592, 612, 629, 649, 669, 689,
709, 730, 751, 772, 794,
]
# fmt: on
k_attacker = values[attacker_level]
return k_attacker
@staticmethod
def cal_res_mul(
data: MultiplierData,
*,
element_type: ElementType | None = None,
snapshot_res_pen=0,
) -> float:
"""抗性区 = 1 - 受击方抗性 + 受击方抗性降低 + 攻击方抗性穿透"""
if element_type is None:
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
# 获取抗性区，初始化为0
if element_type == 0:
element_res = (
data.enemy_obj.PHY_damage_resistance
- data.dynamic.physical_dmg_res_decrease
- data.dynamic.physical_res_pen_increase
)
elif element_type == 1:
element_res = (
data.enemy_obj.FIRE_damage_resistance
- data.dynamic.fire_dmg_res_decrease
- data.dynamic.fire_res_pen_increase
)
elif element_type == 2 or element_type == 5:
element_res = (
data.enemy_obj.ICE_damage_resistance
- data.dynamic.ice_dmg_res_decrease
- data.dynamic.ice_res_pen_increase
)
elif element_type == 3:
element_res = (
data.enemy_obj.ELECTRIC_damage_resistance
- data.dynamic.electric_dmg_res_decrease
- data.dynamic.electric_res_pen_increase
)
elif element_type in [4, 6]:
element_res = (
data.enemy_obj.ETHER_damage_resistance
- data.dynamic.ether_dmg_res_decrease
- data.dynamic.ether_res_pen_increase
)
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
res_mul = (
1
- element_res
+ data.dynamic.all_dmg_res_decrease
+ data.dynamic.all_res_pen_increase
+ snapshot_res_pen
)
# if snapshot_res_pen == 0:
# if isinstance(data.judge_node, SkillNode) and data.judge_node.char_name == "仪玄" and data.judge_node.skill.trigger_buff_level in [2, 6]:
# print(element_res, data.dynamic.all_dmg_res_decrease, data.dynamic.all_res_pen_increase)
return res_mul
@staticmethod
def cal_dmg_vulnerability(
data: MultiplierData, *, element_type: ElementType | None = None
) -> float:
"""
减易伤区 = 1 + 减易伤
"""
if element_type is None:
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
# 获取抗性区，初始化为0
if element_type == 0:
element_vulnerability = data.dynamic.physical_vulnerability
elif element_type == 1:
element_vulnerability = data.dynamic.fire_vulnerability
elif element_type == 2 or element_type == 5:
element_vulnerability = data.dynamic.ice_vulnerability
elif element_type == 3:
element_vulnerability = data.dynamic.electric_vulnerability
elif element_type in [4, 6]:
element_vulnerability = data.dynamic.ether_vulnerability
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
dmg_vulnerability = 1 + element_vulnerability + data.dynamic.all_vulnerability
return dmg_vulnerability
@staticmethod
def cal_stun_vulnerability(data: MultiplierData) -> float:
"""
失衡时：失衡易伤区 = 1 + 怪物失衡易伤 + 失衡易伤增幅 + 全时段失衡易伤（扳机核心被动那种）
非失衡时：失衡易伤区 = 1 + 全时段失衡易伤（扳机核心被动那种）
"""
stun_status: bool = data.enemy_obj.dynamic.stun
if stun_status:
stun_vulnerability = (
1
+ data.enemy_obj.stun_DMG_take_ratio
+ data.dynamic.stun_vulnerability_increase
+ data.dynamic.stun_vulnerability_increase_all_time
)
else:
stun_vulnerability = 1 + data.dynamic.stun_vulnerability_increase_all_time
return stun_vulnerability
@staticmethod
def cal_special_mul(data: MultiplierData) -> float:
return 1 + data.dynamic.special_multiplier_zone
@staticmethod
def cal_sheer_dmg_bonus(data: MultiplierData) -> float:
"""计算贯穿伤害增幅区——贯穿伤害增加是一个独立乘区！"""
assert isinstance(data.judge_node, SkillNode)
if data.judge_node.skill.diff_multiplier != 4:
return 1.0
else:
return 1 + data.dynamic.sheer_dmg_bonus
class AnomalyMul:
"""
负责计算与储存与异常伤害有关的属性
异常伤害快照以 array 形式储存，顺序为：
[基础伤害区、增伤区、异常精通区、等级、异常增伤区、异常暴击区、穿透率、穿透值、抗性穿透]
异常积蓄值 = 基础积蓄值 * 异常掌控/100 * (1 + 属性异常积蓄效率提升) * (1 - 属性异常积蓄抗性)
基础伤害区 = 攻击力 * 对应属性的异常伤害倍率
增伤区 = 1 + 属性增伤 + 全增伤
异常精通区 = 异常精通 / 100
等级 = 角色等级
异常增伤区 = 单独异常增伤
异常暴击区 单独考虑简一个角色
"""
def __init__(self, data: MultiplierData):
assert isinstance(data.judge_node, SkillNode)
self.element_type: ElementType = data.judge_node.element_type
self.anomaly_buildup: np.float64 = self.cal_anomaly_buildup(data)
self.base_damage: float = self.cal_base_damage(data)
self.dmg_bonus: float = self.cal_dmg_bonus(data)
self.ap_mul: float = self.cal_ap_mul(data)
self.level: int = data.char_level if data.char_level is not None else 0
self.anomaly_bonus: float = self.cal_ano_extra_mul(data)
self.anomaly_crit: float = self.cal_anomaly_crit(data)
self.pen_ratio: float = data.static.pen_ratio + data.dynamic.pen_ratio
self.pen_numeric: float = data.static.pen_numeric + data.dynamic.pen_numeric
self.res_pen: float = self.cal_res_pen(data)
self.anomaly_snapshot = np.array(
[
self.base_damage,
self.dmg_bonus,
self.ap_mul,
self.level,
self.anomaly_bonus,
self.anomaly_crit,
self.pen_ratio,
self.pen_numeric,
self.res_pen,
],
dtype=np.float64,
)
@staticmethod
def cal_am(data: MultiplierData) -> np.float64:
am = np.float64(
data.static.am * (1 + data.dynamic.field_anomaly_mastery)
+ data.dynamic.anomaly_mastery
)
return am
@staticmethod
def cal_anomaly_buildup(data: MultiplierData) -> np.float64:
"""异常积蓄值 = 基础积蓄值 * 异常掌控/100 * (1 + 属性异常积蓄效率提升) * (1 - 属性异常积蓄抗性)"""
# 基础蓄积值
assert isinstance(data.judge_node, SkillNode)
accumulation = data.judge_node.skill.anomaly_accumulation
# 异常掌控
am = Calculator.AnomalyMul.cal_am(data)
# 属性异常积蓄效率提升、属性异常积蓄抗性
element_type = data.judge_node.element_type
enemy_buildup_res = data.enemy_obj.anomaly_resistance_dict.get(element_type, 0.0)
if element_type == 0:
element_buildup_bonus = (
data.dynamic.physical_anomaly_buildup_bonus
+ data.dynamic.all_anomaly_buildup_bonus
)
buildup_res = 1 - data.dynamic.physical_anomaly_res_decrease - enemy_buildup_res
elif element_type == 1:
element_buildup_bonus = (
data.dynamic.fire_anomaly_buildup_bonus + data.dynamic.all_anomaly_buildup_bonus
)
buildup_res = 1 - data.dynamic.fire_anomaly_res_decrease - enemy_buildup_res
elif element_type == 2:
element_buildup_bonus = (
data.dynamic.ice_anomaly_buildup_bonus + data.dynamic.all_anomaly_buildup_bonus
)
buildup_res = 1 - data.dynamic.ice_anomaly_res_decrease - enemy_buildup_res
elif element_type == 3:
element_buildup_bonus = (
data.dynamic.electric_anomaly_buildup_bonus
+ data.dynamic.all_anomaly_buildup_bonus
)
buildup_res = 1 - data.dynamic.electric_anomaly_res_decrease - enemy_buildup_res
elif element_type in [4, 6]:
element_buildup_bonus = (
data.dynamic.ether_anomaly_buildup_bonus
+ data.dynamic.all_anomaly_buildup_bonus
)
buildup_res = 1 - data.dynamic.ether_anomaly_res_decrease - enemy_buildup_res
elif element_type == 5:
element_buildup_bonus = (
data.dynamic.frost_anomaly_buildup_bonus
+ data.dynamic.all_anomaly_buildup_bonus
)
buildup_res = 1 - data.dynamic.ice_anomaly_res_decrease - enemy_buildup_res
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
trigger_buff_level = data.judge_node.skill.trigger_buff_level
if trigger_buff_level == 0:
trigger_buildup_bonus = data.dynamic.normal_attack_anomaly_buildup_bonus
elif trigger_buff_level == 1:
trigger_buildup_bonus = data.dynamic.special_skill_anomaly_buildup_bonus
elif trigger_buff_level == 2:
trigger_buildup_bonus = data.dynamic.ex_special_skill_anomaly_buildup_bonus
elif trigger_buff_level == 3:
trigger_buildup_bonus = data.dynamic.dash_attack_anomaly_buildup_bonus
elif trigger_buff_level == 4:
trigger_buildup_bonus = data.dynamic.counter_attack_anomaly_buildup_bonus
elif trigger_buff_level == 5:
trigger_buildup_bonus = data.dynamic.qte_anomaly_buildup_bonus
elif trigger_buff_level == 6:
trigger_buildup_bonus = data.dynamic.ultimate_anomaly_buildup_bonus
elif trigger_buff_level == 7:
trigger_buildup_bonus = data.dynamic.quick_aid_anomaly_buildup_bonus
elif trigger_buff_level == 8:
trigger_buildup_bonus = data.dynamic.defensive_aid_anomaly_buildup_bonus
elif trigger_buff_level == 9:
trigger_buildup_bonus = data.dynamic.assault_aid_anomaly_buildup_bonus
elif trigger_buff_level == 10:
trigger_buildup_bonus = 0
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
element_dmg_percentage = data.judge_node.skill.element_damage_percent
hit_times = data.judge_node.hit_times
anomaly_buildup = (
accumulation
* (am / 100)
* (1 + element_buildup_bonus + trigger_buildup_bonus)
* buildup_res
* element_dmg_percentage
/ hit_times
)
return np.float64(anomaly_buildup)
@staticmethod
def cal_base_damage(data: MultiplierData) -> float:
"""基础伤害区 = 攻击力 * 对应属性的异常伤害倍率"""
base_attr = data.static.atk * (1 + data.dynamic.field_atk_percentage) + data.dynamic.atk
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
if element_type == 0:
base_damage = 7.13 * base_attr
elif element_type == 1:
base_damage = 0.5 * base_attr
elif element_type == 2 or element_type == 5:
base_damage = 5 * base_attr
elif element_type == 3:
base_damage = 1.25 * base_attr
elif element_type in [4, 6]:
base_damage = 0.625 * base_attr
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
return base_damage
@staticmethod
def cal_dmg_bonus(data: MultiplierData) -> float:
"""增伤区 = 1 + 属性增伤 + 全增伤"""
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
if element_type == 0:
element_dmg_bonus = data.static.phy_dmg_bonus + data.dynamic.phy_dmg_bonus
elif element_type == 1:
element_dmg_bonus = data.static.fire_dmg_bonus + data.dynamic.fire_dmg_bonus
elif element_type == 2 or element_type == 5:
element_dmg_bonus = data.static.ice_dmg_bonus + data.dynamic.ice_dmg_bonus
elif element_type == 3:
element_dmg_bonus = data.static.electric_dmg_bonus + data.dynamic.electric_dmg_bonus
elif element_type in [4, 6]:
element_dmg_bonus = data.static.ether_dmg_bonus + data.dynamic.ether_dmg_bonus
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
dmg_bonus = (
1 + element_dmg_bonus + data.dynamic.all_dmg_bonus + data.dynamic.anomaly_dmg_bonus
)
return dmg_bonus
def cal_ap_mul(self, data: MultiplierData) -> float:
"""异常精通区 = 异常精通 / 100"""
ap = self.cal_ap(data)
ap_mul = ap / 100
return ap_mul
@staticmethod
@lru_cache(maxsize=16)
def cal_ap(data: MultiplierData):
ap = (
data.static.ap * (1 + data.dynamic.field_anomaly_proficiency)
+ data.dynamic.anomaly_proficiency
)
return ap
@staticmethod
def cal_ano_extra_mul(data: MultiplierData) -> float:
"""异常额外增伤区 = 1 + 对应属性异常额外增伤"""
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
map = data.dynamic.ano_extra_bonus
ano_dmg_mul = 1 + map.get(element_type, 0) + map["all"]
return ano_dmg_mul
def cal_anomaly_crit(self, data: MultiplierData) -> float:
"""已弃用，避免大范围重构数据类型，保留一个1"""
return 1
def cal_res_pen(self, data: MultiplierData) -> float:
assert isinstance(data.judge_node, SkillNode)
element_type = data.judge_node.element_type
if element_type == 0:
element_res_pen = data.dynamic.physical_res_pen_increase
elif element_type == 1:
element_res_pen = data.dynamic.fire_res_pen_increase
elif element_type == 2 or element_type == 5:
element_res_pen = data.dynamic.ice_res_pen_increase
elif element_type == 3:
element_res_pen = data.dynamic.electric_res_pen_increase
elif element_type in [4, 6]:
element_res_pen = data.dynamic.ether_res_pen_increase
else:
raise AssertionError(INVALID_ELEMENT_ERROR)
return element_res_pen
class StunMul:
"""
负责计算与储存与失衡值有关的属性，并负责与enemy互相
失衡值累积 = 冲击力 * 失衡倍率 * (1 - 失衡抗性) * (1 + 失衡值提升 - 失衡值降低) * (1+ 受到失衡值提升 - 受到失衡值降低)
"""
def __init__(self, data: MultiplierData):
assert isinstance(data.judge_node, SkillNode)
self.element_type: ElementType = data.judge_node.element_type
self.imp = self.cal_imp(data)
self.stun_ratio = self.cal_stun_ratio(data)
self.stun_res = self.cal_stun_res(data, self.element_type)
self.stun_bonus = self.cal_stun_bonus(data)
self.stun_received = self.cal_stun_received(data)
def get_stun_array(self) -> np.ndarray:
stun_array = np.array(
[
self.imp,
self.stun_ratio,
self.stun_res,
self.stun_bonus,
self.stun_received,
],
dtype=np.float64,
)
return stun_array
@staticmethod
def cal_imp(data: MultiplierData) -> float:
imp = data.static.imp * (1 + data.dynamic.field_imp_percentage) + data.dynamic.imp
return imp
@staticmethod
def cal_stun_ratio(data: MultiplierData) -> float:
assert isinstance(data.judge_node, SkillNode)
stun_ratio = data.judge_node.skill.stun_ratio / data.judge_node.hit_times
return stun_ratio
@staticmethod
def cal_stun_res(
data: MultiplierData, element_type: ElementType, *, over_stun_res: float = 0
) -> float:
enemy_stun_res = data.enemy_obj.stun_resistance_dict.get(element_type, 0.0)
stun_res = 1 - data.dynamic.stun_res - over_stun_res - enemy_stun_res
return stun_res
@staticmethod
def cal_stun_bonus(data: MultiplierData) -> float:
# 获取指定label失衡值增加
assert isinstance(data.judge_node, SkillNode)
if (
data.judge_node.skill.labels is not None
and data.judge_node.skill.labels.get("aftershock_attack") == 1
):
label_stun_bonus = data.dynamic.aftershock_attack_stun_bonus
else:
label_stun_bonus = 0
# 接下来计算标签类失衡值
tbl = data.judge_node.skill.trigger_buff_level
if tbl == 0:
stun_bonus_tbl = data.dynamic.normal_attack_stun_bonus
elif tbl == 1:
stun_bonus_tbl = data.dynamic.special_skill_stun_bonus
elif tbl == 2:
stun_bonus_tbl = data.dynamic.ex_special_skill_stun_bonus
elif tbl == 3:
stun_bonus_tbl = data.dynamic.dash_attack_stun_bonus
elif tbl == 4:
stun_bonus_tbl = data.dynamic.counter_attack_stun_bonus
elif tbl == 5:
stun_bonus_tbl = data.dynamic.qte_stun_bonus
elif tbl == 6:
stun_bonus_tbl = data.dynamic.ultimate_stun_bonus
elif tbl == 7:
stun_bonus_tbl = data.dynamic.quick_aid_stun_bonus
elif tbl == 8:
stun_bonus_tbl = data.dynamic.defensive_aid_stun_bonus
elif tbl == 9:
stun_bonus_tbl = data.dynamic.assault_aid_stun_bonus
elif tbl == 10:
stun_bonus_tbl = 0
else:
raise ValueError(
f"{data.judge_node.skill_tag}的trigger_buff_level为{tbl}，无法解析！"
)
all_stun_bonus = data.dynamic.stun_bonus # 全品类失衡增幅
stun_bonus = 1 + stun_bonus_tbl + all_stun_bonus + label_stun_bonus
return stun_bonus
@staticmethod
def cal_stun_received(data: MultiplierData, over_stun_received: float = 0) -> float:
stun_received = 1 + data.dynamic.received_stun_increase + over_stun_received
return stun_received
def cal_dmg_expect(self) -> np.float64:
"""计算伤害期望"""
multipliers: np.ndarray = self.regular_multipliers.get_array_expect()
dmg_expect = np.prod(multipliers)
self.check_skill_node_mul(multipliers)
return np.float64(dmg_expect)
def check_skill_node_mul(self, multipliers):
"""检查技能节点的乘区"""
if not CHECK_SKILL_MUL:
return
if any([__tag in self.skill_tag for __tag in CHECK_SKILL_MUL_TAG]):
tag_list = [
"基础乘区",
"增伤区",
"双暴区",
"防御区",
"抗性区",
"易伤区",
"失衡易伤区",
"特殊乘区",
"贯穿伤害区",
]
print(
self.skill_node.skill.skill_text,
f"第{self.skill_node.loading_mission.hitted_count if self.skill_node.loading_mission else 1}次命中",
"：",
[
f"{__tag} : {__value:.2f}"
for __tag, __value in zip(tag_list, multipliers, strict=True)
],
)
def cal_dmg_crit(self) -> np.float64:
"""计算暴击伤害"""
multipliers: np.ndarray = self.regular_multipliers.get_array_crit()
dmg_crit = np.prod(multipliers)
return np.float64(dmg_crit)
def cal_dmg_not_crit(self) -> np.float64:
"""计算非暴击伤害"""
multipliers: np.ndarray = self.regular_multipliers.get_array_not_crit()
dmg_not_crit = np.prod(multipliers)
return np.float64(dmg_not_crit)
def cal_snapshot(self) -> tuple[int, np.float64, np.ndarray]:
"""计算异常值与失衡值快照，返回一个一维数组，用于计算异常伤害的虚拟角色，鬼知道为什么那么麻烦"""
element_type: int = self.element_type
build_up: np.float64 = self.anomaly_multipliers.anomaly_buildup
anomaly_snapshot: np.ndarray = self.anomaly_multipliers.anomaly_snapshot
stun_snapshot: np.ndarray = np.array(
[self.stun_multipliers.imp, self.stun_multipliers.stun_bonus]
)
snapshot = np.concatenate((anomaly_snapshot, stun_snapshot))
return element_type, build_up, snapshot
def cal_stun(self) -> np.float64:
"""计算失衡值"""
multipliers: np.ndarray = self.stun_multipliers.get_stun_array()
stun = np.prod(multipliers)
return np.float64(stun)
@staticmethod
def update_stun_tick(enemy_obj: Enemy, data: MultiplierData):
"""专门更新延长失衡时间的 buff"""
if data.dynamic.stun_tick_increase >= 1:
enemy_obj.increase_stun_recovery_time(data.dynamic.stun_tick_increase)
# TODO：当前动作是否能够被打断的计算。
# 技能自身有抗打断系数，但是考虑到凯撒之类的抗打断Buff的存在，所以需要在Schedule阶段进行一个全局的计算，
# 在检测到Preload阶段抛出的“怪物进攻”信息后（当前Preload还没有这个功能，应该在这里留好接口），Schedule调取当前动作对应的基础抗打断值，
# 并且从buff系统中读取抗打断加成，最后返回bool值，表示当前动作是否能够被打断。
# TODO：Preload与Schedule阶段在打断功能上的交互与后续设计：
# ①将打断模块放在Schedule的原因：
# 在同一个tick中，理论上说，打断事件在Preload阶段处理或是Schedule阶段处理是一样的，
# 在Schedule阶段处理的好处更多，因为当前tick触发的buff也会被纳入考量。
# 这样可以避免诸多类似于“某添加抗打断buff、但自身不抗打断的技能，在start标签附近被打断”的特殊情况发生
# ②后续设计：
# Schedule阶段在完成判定后，应该第一时间更新一个全局的、或是Preload内部能够读取到的一个指定数据结构
# （该数据结构粗看下来，布尔值应该就能满足要求，但是后续如果还有精确到tick的要求，那可能会变成字典。）
# 而在下一个Tick，Preload会根据这个数据结构中的内容来判断“刚刚那个tick的动作是否被打断了”，
# 这将影响到Preload抛出的是正常主动动作，还是“被打断”的空动作。
if __name__ == "__main__":
pass
================================================
FILE: zsim/sim_progress/ScheduledEvent/__init__.py
================================================
from __future__ import annotations
import logging
from typing import TYPE_CHECKING, Any
from zsim.sim_progress import Buff
from zsim.sim_progress.Character import Character
from zsim.sim_progress.data_struct import (
ActionStack,
PolarizedAssaultEvent,
QuickAssistEvent,
SchedulePreload,
SPUpdateData,
)
from zsim.sim_progress.Load.loading_mission import LoadingMission
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Update import update_anomaly
from .event_handlers import EventContext, event_handler_factory, register_all_handlers
if TYPE_CHECKING:
from zsim.simulator.dataclasses import ScheduleData
from zsim.simulator.simulator_class import Simulator
class ScConditionData:
"""
用于记录在本tick可能的判断 buff 数据，以方便后续计算伤害
"""
def __init__(self):
self.buff_list: list = []
self.when_crit: bool = False
class ScheduledEvent:
"""
计划事件方法类
主逻辑链 self.event_start()：
1、读取计划事件列表，将其中所有的buff示例排到列表最靠前的位置。self.sort_events()
2、遍历事件列表，从开始到结束，将每一个事件派发到分支逻辑链内进行处理
"""
def __init__(
self,
dynamic_buff: dict,
data,
tick: int,
exist_buff_dict: dict,
action_stack: ActionStack,
*,
loading_buff: dict | None = None,
sim_instance: Simulator,
):
self.data: "ScheduleData" = data
self.data.dynamic_buff = dynamic_buff
self.data.processed_times = 0
# self.judge_required_info_dict = data.judge_required_info_dict
self.action_stack = action_stack
if loading_buff is None:
loading_buff = {}
elif not isinstance(loading_buff, dict):
raise ValueError(f"loading_buff参数必须为字典，但你输入了{loading_buff}")
if not isinstance(tick, int):
raise ValueError(f"tick参数必须为整数，但你输入了{tick}")
# 更新Data
self.tick = tick
self.data.loading_buff = loading_buff
self.exist_buff_dict = exist_buff_dict
self.enemy = self.data.enemy
self.execute_tick_key_map = {
SkillNode: "preload_tick",
QuickAssistEvent: "execute_tick",
SchedulePreload: "execute_tick",
PolarizedAssaultEvent: "execute_tick",
}
self.sim_instance: Simulator = sim_instance
# 确保事件处理器已注册
self._ensure_handlers_registered()
def _ensure_handlers_registered(self) -> None:
"""确保所有事件处理器已注册"""
if not event_handler_factory.list_handlers():
register_all_handlers()
logging.info("事件处理器注册完成")
else:
logging.debug("事件处理器已经注册")
def _create_event_context(self) -> EventContext:
"""
创建事件处理上下文
Returns:
EventContext: 包含事件处理所需数据的上下文对象
"""
return EventContext(
data=self.data,
tick=self.tick,
enemy=self.enemy,
dynamic_buff=self.data.dynamic_buff,
exist_buff_dict=self.exist_buff_dict,
action_stack=self.action_stack,
sim_instance=self.sim_instance,
)
def event_start(self):
"""Schedule主逻辑"""
# 更新角色面板
for char in self.data.char_obj_list:
char: Character
sp_update_data = SPUpdateData(char_obj=char, dynamic_buff=self.data.dynamic_buff)
char.update_sp_and_decibel(sp_update_data)
if hasattr(char, "refresh_myself"):
char.refresh_myself()
self.process_event()
def process_event(self):
"""
处理当前所有事件
使用事件处理器模式来处理各种类型的事件，替代原有的大型if-elif链。
提高代码的可读性和可维护性。
"""
if not self.data.event_list:
return
# 先处理优先级高的buff
self.solve_buff()
# 筛选出可处理的事件，并按照优先级排序
processable_events = self.select_processable_event()
# 使用事件处理器处理事件
for event in processable_events:
try:
self._process_single_event(event)
# 事件处理完毕，从列表中移除
self.data.event_list.remove(event)
self.data.processed_times += 1
except Exception as e:
raise RuntimeError(f"处理事件 {type(event)} 时发生错误: {e}") from e
# 如果计算过程中又有新的事件生成，则继续循环
if self.data.event_list and not self.check_all_event():
self.process_event()
def _process_single_event(self, event: Any) -> None:
"""
处理单个事件
Args:
event: 待处理的事件对象
Raises:
NotImplementedError: 当事件类型不被支持时
RuntimeError: 当事件处理器无法找到时
Exception: 事件处理过程中的其他错误
"""
# 特殊处理Buff事件
if isinstance(event, Buff.Buff):
raise NotImplementedError(f"{type(event)}，目前不应存在于 event_list")
# 事件处理上下文
context = self._create_event_context()
# 获取事件处理器
handler = event_handler_factory.get_handler(event)
if handler is None:
error_msg = f"无法找到适合处理事件类型 {type(event)} 的处理器"
logging.error(error_msg)
logging.debug(f"可用的事件处理器: {event_handler_factory.list_handlers()}")
raise RuntimeError(error_msg)
# 处理事件
try:
handler.handle(event, context)
except Exception as e:
logging.error(f"处理事件 {type(event).__name__} 时发生错误: {e}", exc_info=True)
raise
def check_all_event(self):
"""检查所有残留事件是否到期，只要有一个残留事件已经到期，直接返回False，激活递归。"""
for event in self.data.event_list:
# 获取事件类型对应的tick属性名
execute_tick = self.get_execute_tick(event)
if execute_tick is None:
return False
if execute_tick > self.tick: # 严格大于当前tick才视为未到期
continue
else:
return False
return True
def get_execute_tick(self, event) -> int | None:
"""获取事件的执行tick，获取不到则返回None"""
tick_attr = self.execute_tick_key_map.get(type(event), None)
if tick_attr is None:
"""获取不到属性时，说明该event并不具备计划事件的需求，所以这种事件是必须在当前tick被清空的，直接返回None"""
return None
execute_tick = getattr(event, tick_attr, None)
if execute_tick is None:
raise AttributeError(f"{type(event)} 没有属性 {tick_attr}")
return execute_tick
def update_anomaly_bar_after_skill_event(self, event):
"""在Schedule阶段，处理完一个SkillEvent后，都要进行一次异常条更新。"""
"""
将异常值更新移动到Schedule阶段的主要原因：原有的Buff更新、异常/紊乱结算的顺序不合理；
原有顺序：
Preload -> Load -> update_anomaly() -> Buff(第一轮) -> Schedule -> Buff(第二轮)
现有顺序：
Preload -> Load -> Buff(第一轮) -> Schedule -> update_anomaly() -> Buff(第二轮)
由于update_anomaly()函数是根据现有积蓄值来判断是否触发属性异常的，
所以在运行过程中，只有先把积蓄值打满的下一次update_anomaly()才会触发属性异常，
无论是哪种结构，enemy的receive_hit()函数都会在Schedule阶段执行，
故任何早于Schedule阶段的update_anomaly都只能更新到上个tick的属性异常，
所以，原有结构中，第Ntick打满的异常条，会在第N+1 tick被激活，
一般情况下，这种迟滞1tick的激活行为不会对模拟的结果造成影响，
(长难句警告！！)--但若是某个Buff事件的激活 依赖于发生在 技能last_hit标签处的属性异常更新--
那么在老的结构下，事件的更新顺序为
--(第N Tick)--
-> update_anomaly(此时的异常条还没打满[来自于上个tick]所以第Ntick的运行无结果)
-> Buff事件触发器检测（异常条更新状态没有改变，所以触发器不触发）
-> Schedule，异常条满，
--(第N+1 Tick)--
-> update_anomaly(异常条满，更新异常)
-> Buff事件触发器检测（已经错过了触发窗口，所以触发器不触发）
而在新的结构下，事件更新顺序为：
--(第N Tick)--
-> Schedule，异常条满，
-> update_anomaly(异常条满，更新异常)
-> Buff事件触发器检测（将该Buff改为Schedule处理类型）
上述结构的改变就能够彻底规避来自于结构的触发误差——来自柳极性紊乱触发器的启发
"""
if isinstance(event, SkillNode):
_node = event
elif isinstance(event, LoadingMission):
_node = event.mission_node
else:
raise TypeError("无法解析的事件类型")
"""接下来要通过技能的异常更新特性，判断当前Tick的技能是否能够更新异常
由于调用函数的位置是ScheduleEvent，所以一定是Hit事件发生时，
所以，直接调用loading_mission.hitted_count数量就可以获得当前正在被结算的Hit次数。"""
should_update = False
if not _node.skill.anomaly_update_rule:
if _node.loading_mission is None:
_loading_mission = LoadingMission(_node)
_loading_mission.mission_start(timenow=self.sim_instance.tick)
_node.loading_mission = _loading_mission
last_hit = _node.loading_mission.get_last_hit()
if last_hit is not None and self.tick - 1 < last_hit <= self.tick:
should_update = True
else:
if _node.skill.anomaly_update_rule == -1:
should_update = True
else:
if (
_node.loading_mission is not None
and _node.skill.anomaly_update_rule is not None
and (
isinstance(_node.skill.anomaly_update_rule, list)
and _node.loading_mission.hitted_count in _node.skill.anomaly_update_rule
or isinstance(_node.skill.anomaly_update_rule, int)
and _node.loading_mission.hitted_count == _node.skill.anomaly_update_rule
)
):
should_update = True
if should_update:
update_anomaly(
_node.element_type,
self.enemy,
self.tick,
self.data.event_list,
self.data.char_obj_list,
skill_node=_node,
dynamic_buff_dict=self.data.dynamic_buff,
sim_instance=self.sim_instance,
)
def solve_buff(self) -> None:
"""提前处理Buff实例"""
# Buff.buff_add(
# self.tick, self.data.loading_buff, self.data.dynamic_buff, self.data.enemy
# )
buff_events = []
other_events = []
for event in self.data.event_list[:]:
if isinstance(event, Buff.Buff):
buff_events.append(event)
else:
other_events.append(event)
self.data.event_list = buff_events + other_events
def select_processable_event(self):
"""筛选当前可执行的事件，并且按照优先级排序，获取不到优先级的默认为0，"""
_output_event_list = []
for _event in self.data.event_list:
execute_tick = self.get_execute_tick(_event)
if execute_tick is None or execute_tick <= self.tick:
"""说明事件不存在execute_tick或已到期，需要被立刻执行。"""
schedule_priority = getattr(_event, "schedule_priority", 0)
# 使用bisect模块进行高效插入
import bisect
priorities = [getattr(e, "schedule_priority", 0) for e in _output_event_list]
insert_pos = bisect.bisect_right(priorities, schedule_priority)
_output_event_list.insert(insert_pos, _event)
return _output_event_list
if __name__ == "__main__":
pass
================================================
FILE: zsim/sim_progress/ScheduledEvent/buff_effect_trans.json
================================================
{
"固定生命值": "hp",
"固定攻击力": "atk",
"固定防御力": "defense",
"固定冲击力": "imp",
"固定暴击率": "crit_rate",
"固定暴击伤害": "crit_dmg",
"固定异常精通": "anomaly_proficiency",
"固定异常掌控": "anomaly_mastery",
"穿透率": "pen_ratio",
"穿透值": "pen_numeric",
"能量自动恢复": "sp_regen",
"能量获得效率": "sp_get_ratio",
"能量上限": "sp_limit",
"物理属性伤害": "phy_dmg_bonus",
"火属性伤害": "fire_dmg_bonus",
"冰属性伤害": "ice_dmg_bonus",
"电属性伤害": "electric_dmg_bonus",
"以太属性伤害": "ether_dmg_bonus",
"局内生命值%": "field_hp_percentage",
"局内攻击力%": "field_atk_percentage",
"局内防御力%": "field_def_percentage",
"局内冲击力%": "field_imp_percentage",
"局内暴击率": "field_crit_rate",
"局内暴击伤害": "field_crit_dmg",
"局内异常精通": "field_anomaly_proficiency",
"局内异常掌控": "field_anomaly_mastery",
"局内穿透率": "field_pen_ratio",
"局内穿透值": "field_pen_numeric",
"局内能量自动恢复": "sp_regen",
"局内能量获得效率": "sp_get_ratio",
"局内能量上限": "field_sp_limit",
"额外伤害倍率": "extra_damage_ratio",
"固定贯穿力": "sheer_atk",
"局内贯穿力%": "field_sheer_atk_percentage",
"喧响获得效率": "decibel_get_ratio",
"物理属性暴击伤害": "phy_crit_dmg_bonus",
"火属性暴击伤害": "fire_crit_dmg_bonus",
"冰属性暴击伤害": "ice_crit_dmg_bonus",
"电属性暴击伤害": "electric_crit_dmg_bonus",
"以太属性暴击伤害": "ether_crit_dmg_bonus",
"物理属性暴击率": "phy_crit_rate_bonus",
"火属性暴击率": "fire_crit_rate_bonus",
"冰属性暴击率": "ice_crit_rate_bonus",
"电属性暴击率": "electric_crit_rate_bonus",
"以太属性暴击率": "ether_crit_rate_bonus",
"攻击类型增伤": "attack_type_dmg_bonus",
"普攻增伤": "normal_attack_dmg_bonus",
"特殊技增伤": "special_skill_dmg_bonus",
"强化特殊技增伤": "ex_special_skill_dmg_bonus",
"冲刺攻击增伤": "dash_attack_dmg_bonus",
"闪避反击增伤": "counter_attack_dmg_bonus",
"连携技增伤": "qte_dmg_bonus",
"终结技增伤": "ultimate_dmg_bonus",
"快速支援增伤": "quick_aid_dmg_bonus",
"招架支援增伤": "defensive_aid_dmg_bonus",
"支援突击增伤": "assault_aid_dmg_bonus",
"属性异常增伤": "anomaly_dmg_bonus",
"全增伤": "all_dmg_bonus",
"百分比减防": "percentage_def_reduction",
"固定减防": "def_reduction",
"全属性伤害抗性降低": "all_dmg_res_decrease",
"物理伤害抗性降低": "physical_dmg_res_decrease",
"火伤害抗性降低": "fire_dmg_res_decrease",
"冰伤害抗性降低": "ice_dmg_res_decrease",
"电伤害抗性降低": "electric_dmg_res_decrease",
"以太伤害抗性降低": "ether_dmg_res_decrease",
"全属性抗性穿透": "all_res_pen_increase",
"物理抗性穿透": "physical_res_pen_increase",
"火抗性穿透": "fire_res_pen_increase",
"冰抗性穿透": "ice_res_pen_increase",
"电抗性穿透": "electric_res_pen_increase",
"以太抗性穿透": "ether_res_pen_increase",
"全属性异常抗性降低": "all_anomaly_res_decrease",
"物理异常抗性降低": "physical_anomaly_res_decrease",
"火异常抗性降低": "fire_anomaly_res_decrease",
"冰异常抗性降低": "ice_anomaly_res_decrease",
"电异常抗性降低": "electric_anomaly_res_decrease",
"以太异常抗性降低": "ether_anomaly_res_decrease",
"受暴击伤害增加": "received_crit_dmg_bonus",
"被暴击几率增加": "crit_rate_received_increase",
"物理易伤": "physical_vulnerability",
"火易伤": "fire_vulnerability",
"冰易伤": "ice_vulnerability",
"电易伤": "electric_vulnerability",
"以太易伤": "ether_vulnerability",
"异常易伤": "anomaly_vulnerability",
"全易伤": "all_vulnerability",
"失衡抗性": "stun_res",
"失衡增幅": "stun_bonus",
"受失衡增加": "received_stun_increase",
"失衡易伤增加": "stun_vulnerability_increase",
"全时段失衡易伤增加": "stun_vulnerability_increase_all_time",
"普攻失衡值增加": "normal_attack_stun_bonus",
"特殊技失衡值增加": "special_skill_stun_bonus",
"强化特殊技失衡值增加": "ex_special_skill_stun_bonus",
"冲刺攻击失衡值增加": "dash_attack_stun_bonus",
"闪避反击失衡值增加": "counter_attack_stun_bonus",
"连携技失衡值增加": "qte_stun_bonus",
"终结技失衡值增加": "ultimate_stun_bonus",
"快速支援失衡值增加": "quick_aid_stun_bonus",
"招架支援失衡值增加": "defensive_aid_stun_bonus",
"支援突击失衡值增加": "assault_aid_stun_bonus",
"物理积蓄效率增加": "physical_anomaly_buildup_bonus",
"火积蓄效率增加": "fire_anomaly_buildup_bonus",
"冰积蓄效率增加": "ice_anomaly_buildup_bonus",
"电积蓄效率增加": "electric_anomaly_buildup_bonus",
"以太积蓄效率增加": "ether_anomaly_buildup_bonus",
"烈霜积蓄效率增加": "frost_anomaly_buildup_bonus",
"全积蓄效率增加": "all_anomaly_buildup_bonus",
"普攻积蓄效率增加": "normal_attack_anomaly_buildup_bonus",
"特殊技积蓄效率增加": "special_skill_anomaly_buildup_bonus",
"强化特殊技积蓄效率增加": "ex_special_skill_anomaly_buildup_bonus",
"冲刺攻击积蓄效率增加": "dash_attack_anomaly_buildup_bonus",
"闪避反击积蓄效率增加": "counter_attack_anomaly_buildup_bonus",
"连携技积蓄效率增加": "qte_anomaly_buildup_bonus",
"终结技积蓄效率增加": "ultimate_anomaly_buildup_bonus",
"快速支援积蓄效率增加": "quick_aid_anomaly_buildup_bonus",
"招架支援积蓄效率增加": "defensive_aid_anomaly_buildup_bonus",
"支援突击积蓄效率增加": "assault_aid_anomaly_buildup_bonus",
"强击额外伤害增幅": "assault_dmg_mul",
"灼烧额外伤害增幅": "burn_dmg_mul",
"冻结额外伤害增幅": "freeze_dmg_mul",
"感电额外伤害增幅": "shock_dmg_mul",
"侵蚀额外伤害增幅": "chaos_dmg_mul",
"紊乱额外伤害增幅": "disorder_dmg_mul",
"全属性异常额外伤害增幅": "all_anomaly_dmg_mul",
"特殊乘区": "special_multiplier_zone",
"失衡延长": "stun_tick_increase",
"固定基础伤害增加": "base_dmg_increase",
"基础伤害增加%": "base_dmg_increase_percentage",
"追加攻击增伤": "aftershock_attack_dmg_bonus",
"追加攻击暴伤": "aftershock_attack_crit_dmg_bonus",
"追加攻击失衡值增加": "aftershock_attack_stun_bonus",
"畏缩时间延长": "assault_time_increase",
"畏缩时间延长百分比": "assault_time_increase_percentage",
"灼烧时间延长": "burn_time_increase",
"灼烧时间延长百分比": "burn_time_increase_percentage",
"感电时间延长": "shock_time_increase",
"感电时间延长百分比": "shock_time_increase_percentage",
"侵蚀时间延长": "corruption_time_increase",
"侵蚀时间延长百分比": "corruption_time_increase_percentage",
"霜寒时间延长": "frostbite_time_increase",
"霜寒时间延长百分比": "frostbite_time_increase_percentage",
"烈霜霜寒时间延长": "frost_frostbite_time_increase",
"烈霜霜寒时间延长百分比": "frost_frostbite_time_increase_percentage",
"所有异常时间延长": "all_anomaly_time_increase",
"所有异常时间延长百分比": "all_anomaly_time_increase_percentage",
"强击暴击率增加": "strike_crit_rate_increase",
"强击暴击伤害增加": "strike_crit_dmg_increase",
"强击无视防御": "strike_ignore_defense",
"紊乱倍率增加": "all_disorder_basic_mul",
"强击紊乱倍率增加": "strike_disorder_basic_mul",
"灼烧紊乱倍率增加": "burn_disorder_basic_mul",
"霜寒紊乱倍率增加": "frostbite_disorder_basic_mul",
"感电紊乱倍率增加": "shock_disorder_basic_mul",
"侵蚀紊乱倍率增加": "chaos_disorder_basic_mul",
"贯穿伤害增加": "sheer_dmg_bonus"
}
================================================
FILE: zsim/sim_progress/ScheduledEvent/constants.py
================================================
"""
事件常量定义
该模块定义了 ScheduledEvent 模块中使用的各种常量。
"""
class EventConstants:
"""事件相关常量"""
# 默认优先级
DEFAULT_PRIORITY = 0
# 缓存相关
MAX_CACHE_SIZE = 128
# 时间精度
TICK_PRECISION = 0.0000001
# 二分查找阈值
BINARY_SEARCH_THRESHOLD = 10
# 事件列表最大大小
EVENT_LIST_MAX_SIZE = 1000
@classmethod
def validate_constants(cls) -> None:
"""验证常量值的合理性"""
assert cls.MAX_CACHE_SIZE > 0, "缓存大小必须大于0"
assert cls.TICK_PRECISION > 0, "时间精度必须大于0"
assert cls.BINARY_SEARCH_THRESHOLD > 0, "二分查找阈值必须大于0"
assert cls.EVENT_LIST_MAX_SIZE > 0, "事件列表最大大小必须大于0"
assert cls.DEFAULT_PRIORITY >= 0, "默认优先级必须大于等于0"
# 事件类型名称
EVENT_TYPES = {
"skill": "技能事件",
"anomaly": "异常事件",
"disorder": "紊乱事件",
"polarity_disorder": "极性紊乱事件",
"abloom": "薇薇安异放事件",
"refresh": "数据刷新事件",
"quick_assist": "快速支援事件",
"preload": "预加载事件",
"stun_forced_termination": "眩晕强制终止事件",
"polarized_assault": "极性强击事件",
}
# 执行时间键映射
EXECUTE_TICK_KEYS = {
"SkillNode": "preload_tick",
"QuickAssistEvent": "execute_tick",
"SchedulePreload": "execute_tick",
"PolarizedAssaultEvent": "execute_tick",
}
# 优先级定义（数字越大优先级越低）
PRIORITY = {
"HIGH": 0, # 高优先级，数字最小
"MEDIUM": 500, # 中等优先级
"LOW": 800, # 低优先级
"VERY_LOW": 999, # 极低优先级，数字最大
}
# 异常更新规则
ANOMALY_UPDATE_RULES = {
"ALWAYS": -1,
"NEVER": 0,
}
class ErrorMessages:
"""错误消息常量"""
# 参数验证错误
INVALID_LOADING_BUFF_TYPE = "loading_buff参数必须为字典，但你输入了{}"
INVALID_TICK_TYPE = "tick参数必须为整数，但你输入了{}"
TARGET_NOT_FOUND = "[Schedule] target: {} not found in char_obj_list, check the alloc."
CHARACTER_NOT_FOUND = "{} not found in char_obj_list"
INVALID_EVENT_TYPE = "{}，目前不应存在于 event_list"
# 事件处理错误
FUTURE_EVENT_PROCESSING = "event_start主循环正在尝试处理一个名为{}的未来事件"
ATTRIBUTE_NOT_FOUND = "{} 没有属性 {}"
INVALID_EVENT_HANDLER = "无法找到适合处理事件类型 {} 的处理器"
# 缓存错误
CACHE_SIZE_EXCEEDED = "缓存大小超过限制: {}"
CACHE_KEY_NOT_FOUND = "缓存键未找到: {}"
class WarningMessages:
"""警告消息常量"""
# Buff相关警告
DYNAMIC_BUFF_NOT_FOUND = "[WARNING] 动态Buff列表内没有角色 {}"
BUFF_LIST_EMPTY = "[WARNING] Buff列表为空"
# 事件处理警告
EVENT_NOT_HANDLED = "[WARNING] 事件未被处理: {}"
HANDLER_NOT_FOUND = "[WARNING] 未找到事件处理器: {}"
# 性能警告
LARGE_EVENT_LIST = "[WARNING] 事件列表过大: {}"
SLOW_EVENT_PROCESSING = "[WARNING] 事件处理耗时过长: {}s"
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/__init__.py
================================================
"""
事件处理器模块
该模块定义了事件处理的工厂类，用于管理各种类型的事件处理器。
"""
from .base import EventHandlerABC
from .context import EventContext
from .handlers import event_handler_factory, register_all_handlers
__all__ = ["EventHandlerABC", "event_handler_factory", "register_all_handlers", "EventContext"]
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/base.py
================================================
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any
from .context import EventContext
if TYPE_CHECKING:
from zsim.sim_progress.Enemy import Enemy
from zsim.simulator.dataclasses import ScheduleData
class EventHandlerABC(ABC):
"""事件处理器抽象基类"""
@abstractmethod
def can_handle(self, event: Any) -> bool:
"""
判断是否可以处理指定类型的事件
Args:
event: 待处理的事件对象
Returns:
bool: 如果可以处理该类型事件则返回True，否则返回False
"""
pass
@abstractmethod
def handle(self, event: Any, context: EventContext) -> None:
"""
处理事件
Args:
event: 待处理的事件对象
context: 事件处理上下文，包含所需的数据和环境信息
Raises:
NotImplementedError: 如果子类未实现此方法
"""
pass
@property
@abstractmethod
def event_type(self) -> str:
"""
返回处理器支持的事件类型名称
Returns:
str: 事件类型名称
"""
pass
class BaseEventHandler(EventHandlerABC):
"""基础事件处理器，提供通用功能"""
def __init__(self, event_type: str):
self._event_type = event_type
@property
def event_type(self) -> str:
return self._event_type
def _get_context_data(self, context: EventContext) -> ScheduleData:
"""从上下文中获取ScheduleData"""
return context.get_data()
def _get_context_tick(self, context: EventContext) -> int:
"""从上下文中获取当前tick"""
return context.get_tick()
def _get_context_enemy(self, context: EventContext) -> Enemy:
"""从上下文中获取敌人对象"""
return context.get_enemy()
def _get_context_dynamic_buff(self, context: EventContext):
"""从上下文中获取动态buff"""
return context.get_dynamic_buff()
def _get_context_exist_buff_dict(self, context: EventContext):
"""从上下文中获取已存在buff字典"""
return context.get_exist_buff_dict()
def _get_context_action_stack(self, context: EventContext):
"""从上下文中获取动作栈"""
return context.get_action_stack()
def _get_context_sim_instance(self, context: EventContext):
"""从上下文中获取模拟器实例"""
return context.get_sim_instance()
def _validate_event(
self, event: Any, expected_type: type | tuple[type, ...] | None = None
) -> None:
"""
验证事件参数
Args:
event: 待验证的事件对象
expected_type: 期望的事件类型，如果为None则只验证非None
Raises:
TypeError: 当事件类型不符合期望时
ValueError: 当事件为None时
"""
if event is None:
raise ValueError("事件对象不能为None")
if expected_type is not None and not isinstance(event, expected_type):
if isinstance(expected_type, tuple):
expected_names = [t.__name__ for t in expected_type]
raise TypeError(
f"期望事件类型为 {expected_names} 之一，实际得到 {type(event).__name__}"
)
else:
raise TypeError(
f"期望事件类型为 {expected_type.__name__}，实际得到 {type(event).__name__}"
)
def _validate_context(self, context: EventContext) -> None:
"""
验证上下文数据
Args:
context: 待验证的上下文对象
Raises:
ValueError: 当上下文无效时
"""
if not isinstance(context, EventContext): # type: ignore
raise TypeError("上下文必须是EventContext类型")
# Pydantic模型已经确保了数据的完整性和有效性
def _handle_error(self, error: Exception, operation: str, event: Any = None) -> None:
"""
统一错误处理方法
Args:
error: 发生的异常
operation: 操作描述
event: 相关事件对象（可选）
Raises:
RuntimeError: 包装后的异常信息
"""
error_msg = f"在 {operation} 时发生错误: {error}"
if event is not None:
error_msg = f"在 {operation} 事件 {type(event)} 时发生错误: {error}"
raise RuntimeError(error_msg) from error
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/context.py
================================================
"""
事件处理上下文模型
该模块定义了事件处理上下文的dataclass，用于替代字典形式的上下文数据。
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from zsim.sim_progress.Buff import Buff
from zsim.sim_progress.data_struct import ActionStack
from zsim.sim_progress.Enemy import Enemy
from zsim.sim_progress.Preload.SkillsQueue import SkillNode
from zsim.simulator.dataclasses import ScheduleData
from zsim.simulator.simulator_class import Simulator
@dataclass
class EventContext:
"""
事件处理上下文模型
包含事件处理所需的全部数据和对象，使用dataclass提供类型安全和简洁的语法。
"""
data: ScheduleData
tick: int
enemy: Enemy
dynamic_buff: dict[str, list[Buff]]
exist_buff_dict: dict[str, dict[str, Buff]]
action_stack: ActionStack[SkillNode]
sim_instance: Simulator
def get_data(self) -> ScheduleData:
"""获取调度数据对象"""
return self.data
def get_tick(self) -> int:
"""获取当前时间刻"""
return self.tick
def get_enemy(self) -> Enemy:
"""获取敌人对象"""
return self.enemy
def get_dynamic_buff(self) -> dict[str, list[Buff]]:
"""获取动态buff字典"""
return self.dynamic_buff
def get_exist_buff_dict(self) -> dict[str, dict[str, Buff]]:
"""获取已存在buff字典"""
return self.exist_buff_dict
def get_action_stack(self) -> ActionStack[SkillNode]:
"""获取动作栈"""
return self.action_stack
def get_sim_instance(self) -> Simulator:
"""获取模拟器实例"""
return self.sim_instance
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/__init__.py
================================================
"""事件处理器模块
该模块包含所有具体的事件处理器实现和工厂类。
"""
from .abloom import AbloomEventHandler
from .anomaly import AnomalyEventHandler
from .disorder import DisorderEventHandler
from .factory import event_handler_factory
from .polarity_disorder import PolarityDisorderEventHandler
from .polarized_assault import PolarizedAssaultEventHandler
from .preload import PreloadEventHandler
from .quick_assist import QuickAssistEventHandler
from .refresh import RefreshEventHandler
from .skill import SkillEventHandler
from .stun_forced_termination import StunForcedTerminationEventHandler
def register_all_handlers() -> None:
"""注册所有事件处理器"""
handlers = [
SkillEventHandler(),
AnomalyEventHandler(),
DisorderEventHandler(),
PolarityDisorderEventHandler(),
AbloomEventHandler(),
RefreshEventHandler(),
QuickAssistEventHandler(),
PreloadEventHandler(),
StunForcedTerminationEventHandler(),
PolarizedAssaultEventHandler(),
]
for handler in handlers:
event_handler_factory.register_handler(handler)
__all__ = [
"SkillEventHandler",
"AnomalyEventHandler",
"DisorderEventHandler",
"PolarityDisorderEventHandler",
"AbloomEventHandler",
"RefreshEventHandler",
"QuickAssistEventHandler",
"PreloadEventHandler",
"StunForcedTerminationEventHandler",
"PolarizedAssaultEventHandler",
"event_handler_factory",
"register_all_handlers",
]
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/abloom.py
================================================
"""薇薇安异放事件处理器"""
from typing import Any
from zsim.sim_progress import Report
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import DirgeOfDestinyAnomaly as Abloom
from ...CalAnomaly import CalAbloom
from ..base import BaseEventHandler
from ..context import EventContext
class AbloomEventHandler(BaseEventHandler):
"""薇薇安异放事件处理器"""
def __init__(self):
super().__init__("abloom")
def can_handle(self, event: Any) -> bool:
return type(event) is Abloom
def handle(self, event: Abloom, context: EventContext) -> None:
"""处理薇薇安异放事件"""
enemy = self._get_context_enemy(context)
dynamic_buff = self._get_context_dynamic_buff(context)
sim_instance = self._get_context_sim_instance(context)
tick = self._get_context_tick(context)
# 计算异放伤害
calculator = CalAbloom(
abloom_obj=event,
enemy_obj=enemy,
dynamic_buff=dynamic_buff,
sim_instance=sim_instance,
)
damage_anomaly = calculator.cal_anomaly_dmg()
Report.report_dmg_result(
tick=tick,
element_type=event.element_type,
skill_tag="异放",
dmg_expect=round(damage_anomaly, 2),
is_anomaly=True,
dmg_crit=round(damage_anomaly, 2),
stun=0,
buildup=0,
**enemy.dynamic.get_status(),
UUID=event.UUID if event.UUID is not None else "",
)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/anomaly.py
================================================
"""异常事件处理器"""
from typing import Any
from zsim.sim_progress import Report
from zsim.sim_progress.anomaly_bar import AnomalyBar as AnB
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import (
NewAnomaly,
)
from zsim.sim_progress.Buff import ScheduleBuffSettle
from ...CalAnomaly import CalAnomaly
from ..base import BaseEventHandler
from ..context import EventContext
class AnomalyEventHandler(BaseEventHandler):
"""异常事件处理器"""
def __init__(self):
super().__init__("anomaly")
def can_handle(self, event: Any) -> bool:
return type(event) is AnB or type(event) is NewAnomaly
def handle(self, event: AnB | NewAnomaly, context: EventContext) -> None:
"""处理异常事件
处理 AnomalyBar 和 NewAnomaly 两种类型的异常事件，包括：
- 计算异常伤害
- 报告伤害结果
- 处理相关buff结算
"""
# 验证输入
self._validate_event(event, (AnB, NewAnomaly))
self._validate_context(context)
enemy = self._get_context_enemy(context)
dynamic_buff = self._get_context_dynamic_buff(context)
exist_buff_dict = self._get_context_exist_buff_dict(context)
action_stack = self._get_context_action_stack(context)
sim_instance = self._get_context_sim_instance(context)
tick = self._get_context_tick(context)
# 计算异常伤害
calculator = CalAnomaly(
anomaly_obj=event,
enemy_obj=enemy,
dynamic_buff=dynamic_buff,
sim_instance=sim_instance,
)
damage_anomaly = calculator.cal_anomaly_dmg()
Report.report_dmg_result(
tick=tick,
skill_tag=event.rename_tag if event.rename else None,
element_type=event.element_type,
dmg_expect=round(damage_anomaly, 2),
is_anomaly=True,
dmg_crit=round(damage_anomaly, 2),
stun=0,
buildup=0,
**enemy.dynamic.get_status(),
UUID=event.UUID if event.UUID is not None else "",
)
# 处理buff结算
ScheduleBuffSettle(
tick,
exist_buff_dict,
enemy,
dynamic_buff,
action_stack,
anomaly_bar=event,
sim_instance=sim_instance,
)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/disorder.py
================================================
"""紊乱事件处理器"""
from typing import Any
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from zsim.sim_progress import Report
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import Disorder
from ...CalAnomaly import CalDisorder
from ..base import BaseEventHandler
from ..context import EventContext
class DisorderEventHandler(BaseEventHandler):
"""紊乱事件处理器"""
def __init__(self):
super().__init__("disorder")
def can_handle(self, event: Any) -> bool:
return type(event) is Disorder
def handle(self, event: Disorder, context: EventContext) -> None:
"""处理紊乱事件"""
enemy = self._get_context_enemy(context)
dynamic_buff = self._get_context_dynamic_buff(context)
sim_instance = self._get_context_sim_instance(context)
tick = self._get_context_tick(context)
# 广播紊乱事件
sim_instance.listener_manager.broadcast_event(event=event, signal=LBS.DISORDER_SETTLED)
# 计算紊乱伤害
calculator = CalDisorder(
disorder_obj=event,
enemy_obj=enemy,
dynamic_buff=dynamic_buff,
sim_instance=sim_instance,
)
damage_disorder = calculator.cal_anomaly_dmg()
stun = calculator.cal_disorder_stun()
# 更新敌人眩晕值
enemy.update_stun(stun)
Report.report_dmg_result(
tick=tick,
element_type=event.element_type,
dmg_expect=round(damage_disorder, 2),
dmg_crit=round(damage_disorder, 2),
is_anomaly=True,
is_disorder=True,
stun=round(stun, 2),
buildup=0,
**enemy.dynamic.get_status(),
UUID=event.UUID if event.UUID is not None else "",
)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/factory.py
================================================
"""
事件处理器工厂模块
该模块定义了事件处理的工厂类，用于管理各种类型的事件处理器。
"""
from typing import Any
from ..base import EventHandlerABC
class EventHandlerFactory:
"""事件处理器工厂类"""
def __init__(self):
self._handlers: dict[str, EventHandlerABC] = {}
self._handler_cache: dict[type, EventHandlerABC] = {}
self._cache_hits = 0
self._cache_misses = 0
def register_handler(self, handler: EventHandlerABC) -> None:
"""
注册事件处理器
Args:
handler: 事件处理器实例
Raises:
ValueError: 如果已存在相同事件类型的处理器
"""
event_type = handler.event_type
if event_type in self._handlers:
raise ValueError(f"事件类型 '{event_type}' 的处理器已存在")
self._handlers[event_type] = handler
def get_handler(self, event: Any) -> EventHandlerABC | None:
"""
获取适合处理指定事件的处理器（带缓存）
Args:
event: 待处理的事件对象
Returns:
EventHandler | None: 如果找到合适的处理器则返回，否则返回None
"""
# 检查缓存
event_type = type(event)
if event_type in self._handler_cache:
self._cache_hits += 1
return self._handler_cache[event_type]
# 缓存未命中，查找处理器
for handler in self._handlers.values():
if handler.can_handle(event):
self._handler_cache[event_type] = handler
self._cache_misses += 1
return handler
self._cache_misses += 1
return None
def get_handler_by_type(self, event_type: str) -> EventHandlerABC | None:
"""
根据事件类型获取处理器
Args:
event_type: 事件类型名称
Returns:
EventHandler | None: 如果找到处理器则返回，否则返回None
"""
return self._handlers.get(event_type)
def list_handlers(self) -> list[str]:
"""
获取所有已注册的处理器类型列表
Returns:
list[str]: 处理器类型名称列表
"""
return list(self._handlers.keys())
def clear_handlers(self) -> None:
"""清除所有已注册的处理器"""
self._handlers.clear()
self._handler_cache.clear()
def get_cache_stats(self) -> dict[str, int | float]:
"""
获取缓存统计信息
Returns:
dict[str, int]: 包含缓存命中率和统计信息的字典
"""
total_requests = self._cache_hits + self._cache_misses
hit_rate = (self._cache_hits / total_requests * 100) if total_requests > 0 else 0
return {
"cache_hits": self._cache_hits,
"cache_misses": self._cache_misses,
"total_requests": total_requests,
"hit_rate_percent": round(hit_rate, 2),
}
def reset_cache_stats(self) -> None:
"""重置缓存统计信息"""
self._cache_hits = 0
self._cache_misses = 0
def clear_cache(self) -> None:
"""清除处理器缓存"""
self._handler_cache.clear()
self.reset_cache_stats()
# 全局处理器工厂实例
event_handler_factory = EventHandlerFactory()
__all__ = ["event_handler_factory"]
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/polarity_disorder.py
================================================
"""极性紊乱事件处理器"""
from typing import Any
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from zsim.sim_progress import Report
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import PolarityDisorder
from ...CalAnomaly import CalPolarityDisorder
from ..base import BaseEventHandler
from ..context import EventContext
class PolarityDisorderEventHandler(BaseEventHandler):
"""极性紊乱事件处理器"""
def __init__(self):
super().__init__("polarity_disorder")
def can_handle(self, event: Any) -> bool:
return type(event) is PolarityDisorder
def handle(self, event: PolarityDisorder, context: EventContext) -> None:
"""处理极性紊乱事件"""
enemy = self._get_context_enemy(context)
dynamic_buff = self._get_context_dynamic_buff(context)
sim_instance = self._get_context_sim_instance(context)
tick = self._get_context_tick(context)
# 广播极性紊乱事件
sim_instance.listener_manager.broadcast_event(event=event, signal=LBS.DISORDER_SETTLED)
# 计算极性紊乱伤害
calculator = CalPolarityDisorder(
disorder_obj=event,
enemy_obj=enemy,
dynamic_buff=dynamic_buff,
sim_instance=sim_instance,
)
damage_disorder = calculator.cal_anomaly_dmg()
Report.report_dmg_result(
tick=tick,
element_type=event.element_type,
skill_tag="极性紊乱",
dmg_expect=round(damage_disorder, 2),
dmg_crit=round(damage_disorder, 2),
is_anomaly=True,
is_disorder=True,
stun=0,
buildup=0,
**enemy.dynamic.get_status(),
UUID=event.UUID if event.UUID is not None else "",
)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/polarized_assault.py
================================================
"""极性强击事件处理器"""
from typing import Any
from zsim.sim_progress.data_struct import PolarizedAssaultEvent
from ..base import BaseEventHandler
from ..context import EventContext
class PolarizedAssaultEventHandler(BaseEventHandler):
"""极性强击事件处理器"""
def __init__(self):
super().__init__("polarized_assault")
def can_handle(self, event: Any) -> bool:
return type(event) is PolarizedAssaultEvent
def handle(self, event: PolarizedAssaultEvent, context: EventContext) -> None:
"""处理极性强击事件"""
data = self._get_context_data(context)
tick = self._get_context_tick(context)
# 检查是否到达执行时间
if tick < event.execute_tick:
# 时间未到，将事件重新加入列表
data.event_list.append(event)
return
# 执行事件
event.execute()
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/preload.py
================================================
"""预加载事件处理器"""
from typing import Any
from zsim.sim_progress.data_struct import SchedulePreload
from ..base import BaseEventHandler
from ..context import EventContext
class PreloadEventHandler(BaseEventHandler):
"""预加载事件处理器"""
def __init__(self):
super().__init__("preload")
def can_handle(self, event: Any) -> bool:
return isinstance(event, SchedulePreload)
def handle(self, event: SchedulePreload, context: EventContext) -> None:
"""处理预加载事件"""
data = self._get_context_data(context)
tick = self._get_context_tick(context)
# 检查是否到达执行时间
if tick < event.execute_tick:
# 时间未到，将事件重新加入列表
data.event_list.append(event)
return
# 执行事件
event.execute_myself()
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/quick_assist.py
================================================
"""快速支援事件处理器"""
from typing import Any
from zsim.sim_progress.data_struct import QuickAssistEvent
from ..base import BaseEventHandler
from ..context import EventContext
class QuickAssistEventHandler(BaseEventHandler):
"""快速支援事件处理器"""
def __init__(self):
super().__init__("quick_assist")
def can_handle(self, event: Any) -> bool:
return isinstance(event, QuickAssistEvent)
def handle(self, event: QuickAssistEvent, context: EventContext) -> None:
"""处理快速支援事件"""
data = self._get_context_data(context)
tick = self._get_context_tick(context)
# 检查是否到达执行时间
if tick < event.execute_tick:
# 时间未到，将事件重新加入列表
data.event_list.append(event)
return
# 执行事件
event.execute_update(tick)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/refresh.py
================================================
"""数据刷新事件处理器"""
from typing import Any
from zsim.sim_progress.data_struct import ScheduleRefreshData
from ..base import BaseEventHandler
from ..context import EventContext
class RefreshEventHandler(BaseEventHandler):
"""数据刷新事件处理器"""
def __init__(self):
super().__init__("refresh")
def can_handle(self, event: Any) -> bool:
return isinstance(event, ScheduleRefreshData)
def handle(self, event: ScheduleRefreshData, context: EventContext) -> None:
"""处理数据刷新事件"""
try:
data = self._get_context_data(context)
# 创建角色映射
char_mapping = {character.NAME: character for character in data.char_obj_list}
# 更新能量
for target in event.sp_target:
if target != "":
if target not in char_mapping:
raise KeyError(f"目标角色 {target} 未找到")
char_mapping[target].update_sp(event.sp_value)
# 更新喧响
for target in event.decibel_target:
if target != "":
if target not in char_mapping:
raise KeyError(f"目标角色 {target} 未找到")
char_mapping[target].update_decibel(event.decibel_value)
except Exception as e:
self._handle_error(e, "数据刷新事件处理", event)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/skill.py
================================================
"""技能事件处理器"""
from __future__ import annotations
from typing import TYPE_CHECKING, Any
from zsim.sim_progress import Report
from zsim.sim_progress.Buff import ScheduleBuffSettle
from zsim.sim_progress.Character import Character
from zsim.sim_progress.data_struct import (
ActionStack,
SingleHit,
)
from zsim.sim_progress.Load.LoadDamageEvent import (
ProcessFreezLikeDots,
ProcessHitUpdateDots,
)
from zsim.sim_progress.Load.loading_mission import LoadingMission
from zsim.sim_progress.Preload import SkillNode
from zsim.sim_progress.Update import update_anomaly
from ...Calculator import Calculator
from ..base import BaseEventHandler
from ..context import EventContext
if TYPE_CHECKING:
from zsim.sim_progress.Enemy import Enemy
from zsim.simulator.dataclasses import ScheduleData
from zsim.simulator.simulator_class import Simulator
class SkillEventHandler(BaseEventHandler):
"""技能事件处理器"""
def __init__(self):
super().__init__("skill")
def can_handle(self, event: Any) -> bool:
return isinstance(event, SkillNode | LoadingMission)
def handle(self, event: SkillNode | LoadingMission, context: EventContext) -> None:
"""处理技能事件"""
# 验证输入
self._validate_event(event, (SkillNode, LoadingMission))
self._validate_context(context)
data = self._get_context_data(context)
tick = self._get_context_tick(context)
enemy = self._get_context_enemy(context)
dynamic_buff = self._get_context_dynamic_buff(context)
exist_buff_dict = self._get_context_exist_buff_dict(context)
action_stack = self._get_context_action_stack(context)
sim_instance = self._get_context_sim_instance(context)
# 检查是否到达执行时间
execute_tick = self._get_execute_tick(event, context)
if execute_tick is None or execute_tick > tick:
return
self._process_skill_event(
event=event,
data=data,
tick=tick,
enemy=enemy,
dynamic_buff=dynamic_buff,
exist_buff_dict=exist_buff_dict,
action_stack=action_stack,
sim_instance=sim_instance,
)
def _get_execute_tick(
self, event: SkillNode | LoadingMission, context: EventContext
) -> int | None:
"""获取事件的执行tick"""
if isinstance(event, SkillNode):
return event.preload_tick
elif isinstance(event, LoadingMission):
return event.mission_node.preload_tick
return None
def _process_skill_event(
self,
event: SkillNode | LoadingMission,
data: ScheduleData,
tick: int,
enemy: Enemy,
dynamic_buff: dict,
exist_buff_dict: dict,
action_stack: ActionStack,
sim_instance: Simulator,
) -> None:
"""处理技能事件的具体逻辑"""
# 获取技能节点和命中次数
skill_node, hit_count = self._extract_skill_info(event)
# 查找角色对象
char_obj = self._find_character(skill_node.skill.char_name, data.char_obj_list)
# 计算伤害
self._calculate_damage(skill_node, char_obj, enemy, dynamic_buff, hit_count, event, tick)
# 更新异常条
self._update_anomaly_bar_after_skill_event(
skill_node, enemy, tick, data, dynamic_buff, sim_instance
)
# 处理buff结算
self._settle_buffs(
tick, exist_buff_dict, enemy, dynamic_buff, action_stack, skill_node, sim_instance
)
# 处理伤害更新
self._update_damage_effects(tick, enemy, data, event)
self._broadcast_skill_event_to_char(event=event, sim_instance=sim_instance)
def _broadcast_skill_event_to_char(
self, event: SkillNode | LoadingMission, sim_instance: Simulator
) -> None:
"""广播技能事件到所有角色以触发特殊资源更新
Args:
event: 当前技能事件
sim_instance: 模拟器实例
"""
event_to_broadcast = event if isinstance(event, SkillNode) else event.mission_node
for char_obj in sim_instance.char_data.char_obj_list:
if hasattr(char_obj, "update_special_resource"):
char_obj.update_special_resource(event_to_broadcast)
def _extract_skill_info(self, event: SkillNode | LoadingMission) -> tuple[SkillNode, int]:
"""提取技能节点和命中次数信息
Args:
event: 技能事件对象
Returns:
tuple[SkillNode, int]: (技能节点, 命中次数)
"""
if isinstance(event, LoadingMission):
return event.mission_node, event.hitted_count
else:
return event, 0
def _find_character(self, char_name: str, char_obj_list: list[Character]) -> Character:
"""查找角色对象"""
for character in char_obj_list:
if character.NAME == char_name:
return character
raise ValueError(f"角色 {char_name} 未找到")
def _calculate_damage(
self,
skill_node: SkillNode,
char_obj: Character,
enemy: Enemy,
dynamic_buff: dict,
hit_count: int,
event: SkillNode | LoadingMission,
tick: int,
) -> None:
"""计算伤害"""
calculator = Calculator(
skill_node=skill_node,
character_obj=char_obj,
enemy_obj=enemy,
dynamic_buff=dynamic_buff,
)
snapshot = calculator.cal_snapshot()
stun = calculator.cal_stun()
damage_expect = calculator.cal_dmg_expect()
damage_crit = calculator.cal_dmg_crit()
# 获取实际的active_generation值
if isinstance(event, SkillNode):
proactive = event.active_generation
else:
proactive = event.mission_node.active_generation
hit_result = SingleHit(
skill_tag=skill_node.skill_tag,
snapshot=snapshot,
stun=stun,
dmg_expect=damage_expect,
dmg_crit=damage_crit,
hitted_count=hit_count,
proactive=proactive,
)
hit_result.skill_node = skill_node
if skill_node.skill.follow_by:
hit_result.proactive = False
if skill_node.hit_times == hit_count and skill_node.skill.heavy_attack:
hit_result.heavy_hit = True
enemy.hit_received(hit_result, tick) # 使用实际的tick值
Report.report_dmg_result(
tick=tick, # 使用实际的tick值
element_type=skill_node.element_type,
skill_tag=skill_node.skill_tag,
dmg_expect=round(damage_expect, 2),
dmg_crit=round(damage_crit, 2),
stun=round(stun, 2),
buildup=round(snapshot[1], 2),
**enemy.dynamic.get_status(),
UUID=skill_node.UUID if skill_node.UUID is not None else "",
crit_rate=calculator.regular_multipliers.crit_rate,
crit_dmg=calculator.regular_multipliers.crit_dmg,
)
def _update_anomaly_bar_after_skill_event(
self,
skill_node: SkillNode,
enemy: Enemy,
tick: int,
data: ScheduleData,
dynamic_buff: dict,
sim_instance: Simulator,
) -> None:
"""
在技能事件后更新异常条
Args:
skill_node: 技能节点
enemy: 敌人对象
tick: 当前时间刻
data: 调度数据
dynamic_buff: 动态buff
sim_instance: 模拟器实例
"""
# 复制原始 __init__.py 中的 update_anomaly_bar_after_skill_event 逻辑
_node = skill_node
# 判断当前Tick的技能是否能够更新异常
should_update = False
if not _node.skill.anomaly_update_rule:
if _node.loading_mission is None:
_loading_mission = LoadingMission(_node)
_loading_mission.mission_start(timenow=sim_instance.tick)
_node.loading_mission = _loading_mission
last_hit = _node.loading_mission.get_last_hit()
if last_hit is not None and tick - 1 < last_hit <= tick:
should_update = True
else:
if _node.skill.anomaly_update_rule == -1:
should_update = True
else:
if (
_node.loading_mission is not None
and _node.skill.anomaly_update_rule is not None
and (
isinstance(_node.skill.anomaly_update_rule, list)
and _node.loading_mission.hitted_count in _node.skill.anomaly_update_rule
or isinstance(_node.skill.anomaly_update_rule, int)
and _node.loading_mission.hitted_count == _node.skill.anomaly_update_rule
)
):
should_update = True
if should_update:
update_anomaly(
_node.element_type,
enemy,
tick,
data.event_list,
data.char_obj_list,
skill_node=_node,
dynamic_buff_dict=dynamic_buff,
sim_instance=sim_instance,
)
def _settle_buffs(
self,
tick: int,
exist_buff_dict: dict,
enemy: Enemy,
dynamic_buff: dict,
action_stack: ActionStack,
skill_node: SkillNode,
sim_instance: Simulator,
) -> None:
"""处理buff结算
Args:
tick: 当前tick
exist_buff_dict: 已存在的buff字典
enemy: 敌人对象
dynamic_buff: 动态buff字典
action_stack: 动作栈
skill_node: 技能节点
sim_instance: 模拟器实例
"""
ScheduleBuffSettle(
tick,
exist_buff_dict,
enemy,
dynamic_buff,
action_stack,
skill_node=skill_node,
sim_instance=sim_instance,
)
def _update_damage_effects(
self,
tick: int,
enemy: Enemy,
data: ScheduleData,
event: SkillNode | LoadingMission,
) -> None:
"""处理伤害更新效果
Args:
tick: 当前tick
enemy: 敌人对象
data: 调度数据
event: 技能事件对象
"""
ProcessHitUpdateDots(tick, enemy.dynamic.dynamic_dot_list, data.event_list)
ProcessFreezLikeDots(timetick=tick, enemy=enemy, event_list=data.event_list, event=event)
================================================
FILE: zsim/sim_progress/ScheduledEvent/event_handlers/handlers/stun_forced_termination.py
================================================
"""眩晕强制终止事件处理器"""
from typing import Any
from zsim.sim_progress.data_struct import StunForcedTerminationEvent
from ..base import BaseEventHandler
from ..context import EventContext
class StunForcedTerminationEventHandler(BaseEventHandler):
"""眩晕强制终止事件处理器"""
def __init__(self):
super().__init__("stun_forced_termination")
def can_handle(self, event: Any) -> bool:
return type(event) is StunForcedTerminationEvent
def handle(self, event: StunForcedTerminationEvent, context: EventContext) -> None:
"""处理眩晕强制终止事件"""
data = self._get_context_data(context)
tick = self._get_context_tick(context)
# 检查是否到达执行时间
if tick < event.execute_tick:
# 时间未到，将事件重新加入列表
data.event_list.append(event)
return
# 执行事件
event.execute_myself()
================================================
FILE: zsim/sim_progress/Update/UpdateAnomaly.py
================================================
import importlib
from copy import deepcopy
from typing import TYPE_CHECKING
from zsim.define import ELEMENT_TYPE_MAPPING
from zsim.models.event_enums import ListenerBroadcastSignal as LBS
from zsim.sim_progress.anomaly_bar import AnomalyBar
from zsim.sim_progress.anomaly_bar.CopyAnomalyForOutput import (
Disorder,
NewAnomaly,
PolarityDisorder,
)
from zsim.sim_progress.Buff.BuffAddStrategy import buff_add_strategy
from zsim.sim_progress.Dot.BaseDot import Dot
if TYPE_CHECKING:
from zsim.sim_progress.Buff import Buff
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
anomlay_dot_dict = {
0: "Assault",
1: "Ignite",
2: "Freez",
3: "Shock",
4: "Corruption",
5: "Freez",
6: "AuricInkCorruption",
}
def spawn_output(anomaly_bar, mode_number, sim_instance: "Simulator", **kwargs):
"""
该函数用于抛出一个新的属性异常类
"""
if not isinstance(anomaly_bar, AnomalyBar):
raise TypeError(f"{anomaly_bar}不是AnomalyBar类！")
skill_node = kwargs.get("skill_node", None)
# 先处理快照，使其除以总权值。
anomaly_bar.anomaly_settled() if mode_number in [0] else None
# 老逻辑
# anomaly_bar.current_ndarray = (
# anomaly_bar.current_ndarray / anomaly_bar.current_anomaly
# )
# output = anomaly_bar.element_type, anomaly_bar.current_ndarray
output: "AnomalyBar | None" = None
if mode_number == 0:
output = NewAnomaly(anomaly_bar, active_by=skill_node, sim_instance=sim_instance)
elif mode_number == 1:
output = Disorder(anomaly_bar, active_by=skill_node, sim_instance=sim_instance)
elif mode_number == 2:
polarity_ratio = kwargs.get("polarity_ratio", None)
if polarity_ratio is None:
raise ValueError(
"在调用spawn_output函数的模式二（mode_number=2）、企图生成一个极性紊乱对象时，并未传入必须的参数polarity_ratio！"
)
output = PolarityDisorder(
anomaly_bar, polarity_ratio, active_by=skill_node, sim_instance=sim_instance
)
if output is None:
raise ValueError("在调用spawn_output函数时，未正确生成一个AnomalyBar实例！")
# 广播事件
if mode_number in [1, 2]:
sim_instance.listener_manager.broadcast_event(event=output, signal=LBS.DISORDER_SPAWN)
return output
def anomaly_effect_active(
bar: AnomalyBar,
timenow: int,
enemy,
new_anomaly,
element_type,
sim_instance: "Simulator",
):
"""
该函数的作用是创建属性异常附带的debuff和dot，
debuff与dot的index写在了Anomaly.accompany_debuff和Anomaly.accompany_dot里。
这里通过Buff的BuffInitialize函数来根据Buff名，直接提取对应的双字典，
并且直接放进Buff的构造函数内，对新的Buff进行实例化。
然后，回传给exist_buff_dict中的Buff0。
Args:
bar: AnomalyBar: 样本异常条实例，仅用于获取静态信息（多为字符串），不用于业务和运算
timenow: int: 当前时间
enemy: Enemy: 敌人实例
new_anomaly: AnomalyBar: 新触发的异常实例，通常为参与业务的主体，是样本异常条实例的深拷贝
element_type: int: 属性类型（0~6）
sim_instance: Simulator: 模拟器实例
"""
if bar.accompany_debuff:
for debuff in bar.accompany_debuff:
buff_add_strategy(debuff, sim_instance=sim_instance)
if bar.accompany_dot:
new_dot = spawn_anomaly_dot(
element_type, timenow, bar=new_anomaly, sim_instance=sim_instance
)
if new_dot:
for dots in enemy.dynamic.dynamic_dot_list[:]:
if dots.ft.index == new_dot.ft.index:
dots.end(timenow)
enemy.dynamic.dynamic_dot_list.remove(dots)
enemy.dynamic.dynamic_dot_list.append(new_dot)
# event_list.append(new_dot)
def update_anomaly(
element_type: int,
enemy,
time_now: int,
event_list: list,
char_obj_list: list,
sim_instance: "Simulator",
skill_node: "SkillNode",
dynamic_buff_dict: dict[str, list["Buff"]],
**kwargs,
):
"""
该函数需要在Schedule阶段的SkillEvent分支内运行。
用于判断该次属性异常触发应该是新建、替换还是触发紊乱。
第一个参数是属性种类，第二个参数是Enemy类的实例，第三个参数是当前时间
如果判断通过触发，则会立刻实例化一个对应的属性异常实例（自带复制父类的状态与属性），
"""
bar: AnomalyBar = enemy.anomaly_bars_dict[skill_node.element_type]
if not isinstance(bar, AnomalyBar):
raise TypeError(f"{type(bar)}不是Anomaly类！")
active_anomaly_check, active_anomaly_list, last_anomaly_element_type = check_anomaly_bar(enemy)
# 获取当前最大值。修改最大值的操作在确认内置CD转好后再执行。
bar.max_anomaly = getattr(
enemy, f"max_anomaly_{enemy.trans_element_number_to_str[element_type]}"
)
assert bar.max_anomaly is not None and bar.current_anomaly is not None, (
"当前异常值或最大异常值为None！"
)
if bar.current_anomaly >= bar.max_anomaly:
# 积蓄值蓄满了，但是属性异常不一定触发，还需要验证一下内置CD
bar.ready_judge(time_now)
if bar.ready:
# 内置CD检测也通过之后，属性异常正式触发。现将需要更新的信息更新一下。
sim_instance.decibel_manager.update(skill_node=skill_node, key="anomaly")
bar.change_info_cause_active(
time_now, dynamic_buff_dict=dynamic_buff_dict, skill_node=skill_node
)
enemy.update_max_anomaly(element_type)
active_bar = deepcopy(bar)
enemy.dynamic.active_anomaly_bar_dict[element_type] = active_bar
# 异常事件监听器广播
sim_instance.listener_manager.broadcast_event(event=active_bar, signal=LBS.ANOMALY)
if active_bar.element_type in [0]:
sim_instance.listener_manager.broadcast_event(
event=active_bar, signal=LBS.ASSAULT_SPAWN
)
"""
更新完毕，现在正式进入分支判断——触发同类异常 & 触发异类异常（紊乱）。
无论是哪个分支，都需要涉及enemy下的两大容器：enemy_debuff_list以及enemy_dot_list的修改，
同时，也可能需要修改exist_buff_dict以及DYNAMIC_BUFF_DICT
"""
if element_type in active_anomaly_list or active_anomaly_check == 0:
"""
这个分支意味着：新触发了某异常或是同类异常覆盖，此时应该执行的策略是“更新”，模式编码是0
该策略下，只需要抛出一个新的属性异常给dot，不需要改变enemy的信息，只需要更新enemy的dot和debuff 两个list即可。
"""
mode_number = 0
new_anomaly = spawn_output(
active_bar, mode_number, skill_node=skill_node, sim_instance=sim_instance
)
for _char in char_obj_list:
_char.special_resources(new_anomaly)
anomaly_effect_active(
active_bar,
time_now,
enemy,
new_anomaly,
element_type,
sim_instance=sim_instance,
)
if element_type in [2, 5]:
"""
当前分支是冰异常和烈霜异常分支，触发异常后，不向eventlist里面添加事件。
但是如果有老的异常，那么就要立刻去掉老的，换上新的。
最后，frozen的状态参数被打开。
"""
if enemy.dynamic.frozen:
event_list.append(new_anomaly)
# print("新的冰异常触发导致老碎冰直接结算")
enemy.dynamic.frozen = True
# print("触发了新的冰异常！")
else:
"""
只要不是冰和烈霜异常，就直接向eventlist里面添加即可。
"""
event_list.append(new_anomaly)
setattr(enemy.dynamic, enemy.trans_anomaly_effect_to_str[element_type], True)
enemy.dynamic.active_anomaly_bar_dict[element_type] = active_bar
elif element_type not in active_anomaly_list and len(active_anomaly_list) > 0:
"""
这个分支意味着：要结算紊乱。那么需要复制的就不应该是新的这个属性异常，而应该是老的属性异常的bar实例。
为了区分好用于计算的异常积蓄条，
"""
mode_number = 1
last_anomaly_bar = enemy.dynamic.active_anomaly_bar_dict[last_anomaly_element_type]
setattr(
enemy.dynamic,
enemy.trans_anomaly_effect_to_str[last_anomaly_element_type],
False,
)
setattr(enemy.dynamic, enemy.trans_anomaly_effect_to_str[element_type], True)
if element_type in [2, 5]:
# if enemy.dynamic.frozen:
# event_list.append(last_anomaly_bar)
enemy.dynamic.frozen = True
# print("触发了新的冰异常！")
# 旧的激活异常拿出来复制，变成disorder后，从enemy身上清空。
disorder = spawn_output(
last_anomaly_bar,
mode_number,
skill_node=skill_node,
sim_instance=sim_instance,
)
enemy.dynamic.active_anomaly_bar_dict[last_anomaly_element_type] = None
enemy.anomaly_bars_dict[last_anomaly_element_type].active = False
remove_dots_cause_disorder(disorder, enemy, event_list, time_now)
# 新的激活异常根据原来的Bar进行复制，并且添加到enemy身上。
new_anomaly = spawn_output(
active_bar, 0, skill_node=skill_node, sim_instance=sim_instance
)
anomaly_effect_active(
active_bar,
time_now,
enemy,
new_anomaly,
element_type,
sim_instance=sim_instance,
)
enemy.dynamic.active_anomaly_bar_dict[element_type] = active_bar
# 向eventlist中添加事件。主要包括非烈霜、冰属性的新异常，以及紊乱。
if element_type not in [2, 5]:
event_list.append(new_anomaly)
for obj in char_obj_list:
obj.special_resources(disorder)
event_list.append(disorder)
sim_instance.decibel_manager.update(skill_node=skill_node, key="disorder")
enemy.sim_instance.schedule_data.change_process_state()
if disorder.activated_by:
print(
f"由【{disorder.activated_by.char_name}】的【{disorder.activated_by.skill_tag}】技能触发了紊乱！【{ELEMENT_TYPE_MAPPING[last_anomaly_bar.element_type]}】属性的异常状态提前结束！"
)
# 在异常与紊乱两个分支的最后，清空bar的异常积蓄和快照。
else:
raise ValueError("无法解析的异常/紊乱分支")
bar.reset_current_info_cause_output()
def remove_dots_cause_disorder(disorder, enemy, event_list, time_now):
"""
该函数只负责移除dot。
"""
remove_dots_list = []
for dots in enemy.dynamic.dynamic_dot_list:
if not isinstance(dots, Dot):
raise TypeError(f"{dots}不是DOT类！")
if dots.ft.index in ["Freez", "Freezdot"] or dots.ft.index == disorder.accompany_dot:
if dots.dy.effect_times > dots.ft.max_effect_times:
raise ValueError("该Dot任务已经完成，应当被删除！")
remove_dots_list.append(dots)
else:
sim_instance = enemy.sim_instance
for _dot in remove_dots_list:
if _dot.ft.index in ["Freez", "Freezdot"]:
event_list.append(_dot.anomaly_data)
_dot.dy.ready = False
_dot.dy.last_effect_ticks = time_now
_dot.dy.effect_times += 1
_dot.end(time_now)
enemy.dynamic.dynamic_dot_list.remove(_dot)
enemy.dynamic.frozen = False
enemy.dynamic.frostbite = False
else:
_dot.end(time_now)
enemy.dynamic.dynamic_dot_list.remove(_dot)
sim_instance.schedule_data.change_process_state()
print(f"因紊乱而强行移除Dot {_dot.ft.index}")
def check_anomaly_bar(enemy):
"""
自检函数：
1、检查当前激活的属性异常数量是否>2，如果是直接报错。
2、由于冰与烈霜异常会导致2,5同时进入active_anomaly_check列表，所以这里要进行筛选
"""
active_anomaly_check = 0
active_anomaly_list = []
anomaly_name_list = []
for (
element_number,
element_anomaly_effect,
) in enemy.trans_anomaly_effect_to_str.items():
if getattr(enemy.dynamic, element_anomaly_effect):
anomaly_name_list.append(element_anomaly_effect)
anomaly_name_list_unique = list(set(anomaly_name_list))
active_anomaly_check = len(anomaly_name_list_unique)
active_anomaly_list.append(element_number)
if active_anomaly_check >= 2:
raise ValueError("当前同时存在两种以上的异常状态！！！")
last_anomaly_element_type: int | None = None
if len(active_anomaly_list) == 1:
last_anomaly_element_type = active_anomaly_list[0]
elif len(active_anomaly_list) == 2:
if active_anomaly_list == [2, 5]:
for number in [2, 5]:
if enemy.anomaly_bars_dict[number].active:
last_anomaly_element_type = number
break
else:
raise TypeError(f"当前激活的异常类型列表为{active_anomaly_list}，是预期之外的值。")
else:
last_anomaly_element_type = None
return active_anomaly_check, active_anomaly_list, last_anomaly_element_type
def spawn_anomaly_dot(
element_type, timenow, bar=None, skill_tag=None, sim_instance: "Simulator | None" = None
):
if element_type in anomlay_dot_dict:
class_name = anomlay_dot_dict[element_type]
new_dot = create_dot_instance(class_name, sim_instance=sim_instance, bar=bar)
if isinstance(new_dot, Dot):
new_dot.start(timenow)
return new_dot
else:
return False
def spawn_normal_dot(dot_index, sim_instance: "Simulator", bar=None):
if sim_instance is None:
raise ValueError("sim_instance不能为空！")
new_dot = create_dot_instance(dot_index, sim_instance=sim_instance, bar=bar)
return new_dot
def create_dot_instance(class_name: str, sim_instance: "Simulator | None" = None, bar=None):
# 动态导入相应模块
module_name = f"zsim.sim_progress.Dot.Dots.{class_name}" # 假设你的类都在dot.DOTS模块中
try:
module = importlib.import_module(module_name) # 导入模块
class_obj = getattr(module, class_name) # 获取类对象
if bar:
dot_obj: Dot = class_obj(bar=bar, sim_instance=sim_instance)
else:
dot_obj: Dot = class_obj(sim_instance=sim_instance)
return dot_obj # 创建并返回类实例
except (ModuleNotFoundError, AttributeError) as e:
raise ValueError(f"Error loading class {class_name}: {e}")
================================================
FILE: zsim/sim_progress/Update/Update_Buff.py
================================================
from zsim.sim_progress.Buff import Buff
from zsim.sim_progress.Dot import BaseDot
from zsim.sim_progress.Enemy import Enemy
from zsim.sim_progress.Report import report_buff_to_queue, report_to_log
def update_time_related_effect(
DYNAMIC_BUFF_DICT: dict, timetick, exist_buff_dict: dict, enemy: Enemy
):
"""
更新一些和时间相关的效果，异常条、Buff、Dot
"""
update_anomaly_bar(timetick, enemy)
update_buff(DYNAMIC_BUFF_DICT, enemy, exist_buff_dict, timetick)
update_dot(enemy, timetick)
return DYNAMIC_BUFF_DICT
def update_buff(DYNAMIC_BUFF_DICT, enemy, exist_buff_dict, timetick):
"""
该函数用于更新当前正处于活跃状态的Buff，
并且根据时间或是其他规则判断这些Buff是否应该结束。
结束的Buff会被移除。
注意，该函数的运行位置会导致所有Buff于Ntick末尾消失的Buff在N+1tick的开头处理，
当然这大部分情况下不会影响正确性。
"""
for charname, sub_dynamic_buff_list in DYNAMIC_BUFF_DICT.items():
remove_buff_list = []
for _ in sub_dynamic_buff_list:
CheckBuff(_, charname)
# 首先根据Buff的结束行为是否复杂进行分流
if not _.ft.simple_exit_logic:
# 结束行为复杂的Buff，其结束逻辑由xexit()控制
try:
shoud_exit = _.logic.xexit(beneficiary=charname)
except TypeError:
raise TypeError(f"{_.ft.index}的xexit方法参数错误！") # noqa: B904
if not shoud_exit:
# 如果buff的xexit()函数认为buff不应该结束，则再记录一次层数。
report_buff_to_queue(charname, timetick, _.ft.index, _.dy.count, True, level=4)
else:
# 若buff的xexit()函数认为buff应该结束，则移除buff
remove_buff_list.append(_)
else:
# 处理完了结束行为较为复杂的Buff，现在来处理结束行为简单的Buff
# 对于alltime的buff，自然是每个tick都存在，所以每个tick都记录。
if _.ft.alltime:
report_buff_to_queue(charname, timetick, _.ft.index, _.dy.count, True, level=4)
continue
# 对于层数独立结算的buff，需要特殊判断；
if _.ft.individual_settled:
if len(_.dy.built_in_buff_box) <= 0:
# 层数为0时候结束
remove_buff_list.append(_)
continue
else:
process_individual_buff(_, timetick)
# 先更新层数，再report。
report_buff_to_queue(
charname, timetick, _.ft.index, _.dy.count, True, level=4
)
# 接下来处理的是层数不独立结算的buff
else:
# 层数不独立的buff，时间到点了就要结束。
if timetick > _.dy.endticks:
remove_buff_list.append(_)
continue
# 没结束的buffreport一下层数。
else:
report_buff_to_queue(
charname, timetick, _.ft.index, _.dy.count, True, level=4
)
else:
# 统一执行KickOut函数，移除buff
sub_exist_buff_dict = exist_buff_dict[charname]
for removed_buff in remove_buff_list:
KickOutBuff(
DYNAMIC_BUFF_DICT,
removed_buff,
charname,
enemy,
sub_exist_buff_dict,
timetick,
)
def process_individual_buff(_, timetick):
"""
针对层数独立结算的buff的tuple的独立结算。去除过期的tuple
"""
end_tuples_list = []
for tuples in _.dy.built_in_buff_box:
if tuples[1] < timetick:
end_tuples_list.append(tuples)
else:
for _end_tuples in end_tuples_list:
_.dy.built_in_buff_box.remove(_end_tuples)
_.dy.count = len(_.dy.built_in_buff_box)
def KickOutBuff(
DYNAMIC_BUFF_DICT: dict,
buff: Buff,
charname: str,
enemy,
sub_exist_buff_dict: dict,
timetick: int,
):
buff.end(timetick, sub_exist_buff_dict)
DYNAMIC_BUFF_DICT[charname].remove(buff)
report_to_log(
f"[Buff END]:{timetick}:{charname} 的 {buff.ft.index} 结束，已从动态列表移除", level=4
)
if buff.ft.is_debuff:
enemy.dynamic.dynamic_debuff_list.remove(buff)
def CheckBuff(_, charname):
"""
检查buff的参数情况。
"""
if not isinstance(_, Buff):
raise TypeError(f"{_}不是Buff类！")
if _.ft.is_debuff and charname != "enemy":
raise ValueError(f"{_.ft.index}是debuff但是却进入了{charname}的buff池！")
if (not _.ft.is_debuff) and charname == "enemy":
raise ValueError(f"{_.ft.index}是buff但是却在enemy的debuff池中！")
def update_dot(enemy: Enemy, timetick):
for _ in enemy.dynamic.dynamic_dot_list[:]:
if not isinstance(_, BaseDot.Dot):
raise TypeError(f"Enemy的dot列表中的{_}不是Dot类！")
if not _.ft.complex_exit_logic:
if timetick >= _.dy.end_ticks:
_.end(timetick)
enemy.dynamic.dynamic_dot_list.remove(_)
report_to_log(f"[Dot END]:{timetick}:{_.ft.index}结束，已从动态列表移除", level=4)
else:
exit_result = _.exit_judge(enemy=enemy)
# 不是所有的dot的退出函数都有返回，这里必须处理退出函数不返回内容的情况
if exit_result is None:
raise ValueError("复杂退出逻辑Dot的退出函数必须返回有效布尔值")
if exit_result:
_.end(timetick)
enemy.dynamic.dynamic_dot_list.remove(_)
report_to_log(f"[Dot END]:{timetick}:{_.ft.index}结束，已从动态列表移除", level=4)
def update_anomaly_bar(time_now: int, enemy: Enemy):
for element_type, bar in enemy.anomaly_bars_dict.items():
result = bar.check_myself(time_now)
if result:
setattr(
enemy.dynamic,
enemy.trans_anomaly_effect_to_str[element_type],
bar.active,
)
enemy.dynamic.active_anomaly_bar_dict[element_type] = None
================================================
FILE: zsim/sim_progress/Update/__init__.py
================================================
from .UpdateAnomaly import spawn_output, update_anomaly
__all__ = [
"spawn_output",
"update_anomaly",
]
================================================
FILE: zsim/sim_progress/__init__.py
================================================
================================================
FILE: zsim/sim_progress/anomaly_bar/Anomalies.py
================================================
from dataclasses import dataclass
from .AnomalyBarClass import AnomalyBar
@dataclass
class PhysicalAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__()
self.element_type = 0
self.accompany_debuff = ["Buff-异常-畏缩"]
self.max_duration = 0
self.duration_buff_list = ["Buff-角色-简-核心被动-啮咬触发器"]
self.basic_max_duration = 600
self.duration_buff_key_list = [
"畏缩时间延长",
"所有异常时间延长",
"畏缩时间延长百分比",
"所有异常时间延长百分比",
]
def __hash__(self):
return hash(self.UUID)
@dataclass
class FireAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__() # 调用父类的初始化方法
self.accompany_dot = "Ignite"
self.element_type = 1 # 火属性
self.basic_max_duration = 600
self.duration_buff_list = ["Buff-角色-柏妮思-组队被动-延长灼烧"]
self.max_duration = 0
self.duration_buff_key_list = [
"灼烧时间延长",
"所有异常时间延长",
"灼烧时间延长百分比",
"所有异常时间延长百分比",
]
@dataclass
class IceAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__() # 调用父类的初始化方法
self.element_type = 2 # 冰属性
self.accompany_debuff = ["Buff-异常-霜寒"]
self.accompany_dot = "Freez"
self.basic_max_duration = 600
self.max_duration = 0
self.duration_buff_key_list = [
"霜寒时间延长",
"所有异常时间延长",
"霜寒时间延长百分比",
"所有异常时间延长百分比",
]
# 冻结时间可以延长失衡
@dataclass
class ElectricAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__() # 调用父类的初始化方法
self.element_type = 3 # 电属性
self.accompany_dot = "Shock"
self.basic_max_duration = 600
self.duration_buff_list = ["Buff-角色-丽娜-组队被动-延长感电"]
self.max_duration = 0
self.duration_buff_key_list = [
"感电时间延长",
"所有异常时间延长",
"感电时间延长百分比",
"所有异常时间延长百分比",
]
@dataclass
class EtherAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__() # 调用父类的初始化方法
self.element_type = 4 # 以太属性
self.accompany_dot = "Corruption"
self.basic_max_duration = 600
self.max_duration = 0
self.duration_buff_key_list = [
"侵蚀时间延长",
"所有异常时间延长",
"侵蚀时间延长百分比",
"所有异常时间延长百分比",
]
@dataclass
class FrostAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__() # 调用父类的初始化方法
self.element_type = 5 # 烈霜属性（星见雅专属）
self.accompany_dot = "Freez"
self.basic_max_duration = 1200
self.accompany_debuff = ["Buff-异常-烈霜霜寒", "Buff-角色-雅-核心被动-霜灼"]
self.max_duration = 0
self.duration_buff_key_list = [
"烈霜霜寒时间延长",
"所有异常时间延长",
"烈霜霜寒时间延长百分比",
"所有异常时间延长百分比",
]
@dataclass
class AuricInkAnomaly(AnomalyBar):
def __post_init__(self):
super().__post_init__() # 调用父类的初始化方法
self.element_type = 6 # 玄墨侵蚀的属性也是以太
self.accompany_dot = "AuricInkCorruption"
self.basic_max_duration = 600
self.max_duration = 0
self.duration_buff_key_list = [
"玄墨侵蚀时间延长",
"所有异常时间延长",
"玄墨侵蚀时间延长百分比",
"所有异常时间延长百分比",
]
================================================
FILE: zsim/sim_progress/anomaly_bar/AnomalyBarClass.py
================================================
import uuid
from dataclasses import dataclass, field
from typing import TYPE_CHECKING
import numpy as np
from zsim.define import ElementType
if TYPE_CHECKING:
from zsim.sim_progress.Buff import Buff
from zsim.sim_progress.data_struct.single_hit import SingleHit
from zsim.sim_progress.Preload import SkillNode
from zsim.simulator.simulator_class import Simulator
@dataclass
class AnomalyBar:
"""
这是属性异常类的基类。其中包含了属性异常的基本属性，以及几个基本方法。
"""
sim_instance: "Simulator"
element_type: ElementType = 0 # 属性种类编号(1~5)
is_disorder: bool = False # 是否是紊乱实例
current_ndarray: np.ndarray = field(
default_factory=lambda: np.zeros((1, 1), dtype=np.float64)
) # 当前快照总和
current_anomaly: np.float64 = field(
default_factory=lambda: np.float64(0)
) # 当前已经累计的积蓄值
current_effective_anomaly: np.float64 = field(
default_factory=lambda: np.float64(0)
) # 有效积蓄值（参与快照的）
anomaly_times: int = 0 # 迄今为止触发过的异常次数
cd: int = 180 # 属性异常的内置CD，
last_active: int = 0 # 上一次属性异常的时间
max_anomaly: int | None = None # 最大积蓄值
ready: bool = True # 内置CD状态
accompany_debuff: list | None = None # 是否在激活时伴生debuff的index
accompany_dot: str | None = None # 是否在激活时伴生dot的index
active: bool | None = None # 当前异常条是否激活，这一属性和enemy下面的异常开关同步。
max_duration: int | None = None
duration_buff_list: list | None = None # 影响当前异常状态最大时长的buff名
duration_buff_key_list: list | None = None # 影响当前异常状态最大时长的buff效果关键字
basic_max_duration: int = 0 # 基础最大时间
UUID: uuid.UUID | None = None
activated_by: "SkillNode | None" = None
ndarray_box: list[tuple] | None = None
scaling_factor: float = 1.0 # 缩放比例，在计算伤害时会乘以该比例
settled: bool = False # 快照是否被结算过
rename_tag: str | None = None # 重命名标签
schedule_priority: int = 999 # 默认情况下，异常条的处理优先级为999，位于当前tick的最后。
@property
def rename(self) -> bool:
return self.rename_tag is not None
def __post_init__(self):
self.UUID = uuid.uuid4()
def __hash__(self):
return hash(self.UUID)
@property
def is_full(self):
assert self.max_anomaly is not None
return self.current_anomaly >= self.max_anomaly
def remaining_tick(self):
timetick = self.sim_instance.tick
assert self.max_duration is not None
remaining_tick = max(self.max_duration - self.duration(timetick), 0)
return remaining_tick
def duration(self, timetick: int):
duration = timetick - self.last_active
if self.max_duration is not None:
assert duration <= self.max_duration, "该异常早就结束了！不应该触发紊乱！"
else:
raise AssertionError("该异常的max_duration为None，无法判断是否过期！")
return duration
def update_snap_shot(self, new_snap_shot: tuple, single_hit: "SingleHit"):
"""
该函数是更新快照的核心函数。但是并不具备识别属性种类的功能。
所以需要在外部嵌套一个总函数，根据属性种类来执行不同属性的update函数。
"""
if not isinstance(new_snap_shot[2], np.ndarray):
raise TypeError("所传入的快照元组的第3个元素应该是np.ndarray！")
#
# new_ndarray = new_snap_shot[2].reshape(1, -1) # 将数据重塑为一行多列的形式
build_up_value = new_snap_shot[1] # 获取积蓄值
#
# assert self.current_ndarray is not None, "当前快照数组为None！"
# if self.current_ndarray.shape[1] != new_ndarray.shape[1]:
# # 扩展 current_ndarray 列数，保持已有数据，新增的部分会填充为零
# if self.current_ndarray.shape[1] < new_ndarray.shape[1]:
# # 扩展 current_ndarray 列数，增加零列
# new_shape = (1, new_ndarray.shape[1])
# extended_ndarray = np.zeros(new_shape, dtype=np.float64)
# # 将已有的数据复制到新的 ndarray 中
# extended_ndarray[:, : self.current_ndarray.shape[1]] = (
# self.current_ndarray
# )
# self.current_ndarray = extended_ndarray
# else:
# # 如果 current_ndarray 列数大于 new_ndarray 列数，直接裁剪 current_ndarray
# raise ValueError(
# f"传入的快照数组列数为{new_ndarray.shape[1]}，小于快照缓存的列数！"
# )
#
# cal_result_1 = build_up_value * new_ndarray
# self.current_ndarray += cal_result_1
self.current_anomaly += build_up_value
# print(f"测试：{self.sim_instance.tick}tick：{single_hit.skill_tag}命中！积蓄了{build_up_value}点{ELEMENT_TYPE_MAPPING[new_snap_shot[0]]}属性积蓄！当前积蓄值为：{self.current_anomaly}")
if single_hit.effective_anomlay_buildup():
# 只有有效积蓄才会累计快照
if self.ndarray_box is None:
self.ndarray_box = []
self.ndarray_box.append(new_snap_shot)
def ready_judge(self, timenow):
if timenow - self.last_active >= self.cd:
self.ready = True
def check_myself(self, timenow: int):
assert self.max_duration is not None, "该异常的max_duration为None，无法判断是否过期！"
if self.active and (self.last_active + self.max_duration < timenow):
self.active = False
return True
return False
def change_info_cause_active(
self,
timenow: int,
skill_node: "SkillNode",
dynamic_buff_dict: dict[str, list["Buff"]],
):
"""
属性异常激活时，必要的信息更新
"""
char_cid = int(skill_node.skill_tag.strip().split("_")[0])
self.ready = False
self.anomaly_times += 1
self.last_active = timenow
self.active = True
self.activated_by = skill_node
self.__get_max_duration(dynamic_buff_dict, char_cid)
# self.sim_instance.schedule_data.change_process_state()
# print(
# f"{skill_node.char_name}的技能【{self.activated_by.skill_tag}】激活了【{ELEMENT_TYPE_MAPPING[self.element_type]}】属性的异常状态！\n技能为{skill_node.skill_tag}， preload_tick为{skill_node.preload_tick}， end_tick为{skill_node.end_tick}，tick_list为{skill_node.tick_list}"
# )
def reset_current_info_cause_output(self):
"""
重置和属性积蓄条以及快照相关的信息。
该函数通常位于抛出异常实例之前调用，
"""
self.current_effective_anomaly = np.float64(0)
self.current_anomaly = np.float64(0)
self.current_ndarray = np.zeros((1, self.current_ndarray.shape[0]), dtype=np.float64)
self.ndarray_box = []
self.settled = False
def get_buildup_pct(self):
if self.max_anomaly is None:
return 0
if self.is_full:
return 1
pct = self.current_anomaly / self.max_anomaly
return pct
def reset_myself(self):
self.current_ndarray = np.zeros((1, 1), dtype=np.float64)
self.current_anomaly = np.float64(0)
self.anomaly_times = 0
self.last_active = 0
self.ready = True
self.active = False
self.max_anomaly = None
self.ndarray_box = []
def __get_max_duration(self, dynamic_buff_list, anomaly_from: int | str) -> None:
"""通过Buff计算当前异常的最大持续时间"""
if self.duration_buff_list is None:
self.max_duration = self.basic_max_duration
# print(f'属性类型为{self.element_type}的异常不存在影响持续时间的Buff，所以直接使用基础值{self.basic_max_duration}')
return
max_duration_delta_fix = 0
max_duration_delta_pct = 0
for _buff_index in self.duration_buff_list:
enemy_buff_list = dynamic_buff_list.get("enemy")
for buffs in enemy_buff_list:
if _buff_index == buffs.ft.index and buffs.dy.active:
for keys in self.duration_buff_key_list: # type: ignore
if keys in buffs.effect_dct.keys():
if "百分比" in keys:
max_duration_delta_pct += buffs.dy.count * buffs.effect_dct.get(
keys
)
else:
max_duration_delta_fix += buffs.dy.count * buffs.effect_dct.get(
keys
)
self.max_duration = max(
self.basic_max_duration * (1 + max_duration_delta_pct) + max_duration_delta_fix,
0,
)
# print(f'属性类型为{self.element_type}的异常激活了，本次激活的最大时长为{self.max_duration}')
@staticmethod
def create_new_from_existing(existing_instance):
"""
通过复制已有实例的状态来创建新实例
"""
new_instance = AnomalyBar.__new__(AnomalyBar) # 不调用构造函数
new_instance.__dict__ = existing_instance.__dict__.copy() # 复制原实例的属性
return new_instance
def __deepcopy__(self, memo):
"""AnomalyBar的deepcopy方法，需要绕开Buff"""
import copy
cls = self.__class__
new_anomaly_bar = cls.__new__(cls)
memo[id(self)] = new_anomaly_bar
# 安全复制属性
for key, value in self.__dict__.items():
if key == "sim_instance":
# 直接复制 Simulator 引用（避免深拷贝 Buff）
setattr(new_anomaly_bar, key, value)
elif key == "activated_by" and hasattr(value, "skill"):
# 复制 SkillNode 但不深拷贝其内部技能对象
new_skill_node = copy.copy(value)
setattr(new_anomaly_bar, key, new_skill_node)
elif key == "current_ndarray" and value is not None:
# 使用 numpy 的安全复制方法
setattr(new_anomaly_bar, key, value.copy())
elif key == "current_anomaly" and value is not None:
# 安全复制 np.float64
setattr(new_anomaly_bar, key, copy.copy(value))
elif key == "UUID":
# 生成新的 UUID
setattr(new_anomaly_bar, key, uuid.uuid4())
else:
try:
# 尝试标准深拷贝
setattr(new_anomaly_bar, key, copy.deepcopy(value, memo))
except TypeError:
# 无法深拷贝时回退到浅拷贝
setattr(new_anomaly_bar, key, value)
return new_anomaly_bar
def anomaly_settled(self):
"""结算快照！"""
if self.settled:
raise RuntimeError(
"【异常条结算警告】当前异常条快照已经被结算过一次了，请检查业务逻辑，找出重复结算的时间点！"
)
total_array = np.zeros((1, 1), dtype=np.float64)
effective_buildup: np.float64 = np.float64(0)
while self.ndarray_box:
_tuples = self.ndarray_box.pop()
_element_type = _tuples[0]
_array = _tuples[2].reshape(1, -1)
_build_up = _tuples[1]
if total_array.shape[1] != _array.shape[1]:
if total_array.shape[1] < _array.shape[1]:
new_shape = (1, _array.shape[1])
extended_ndarray = np.zeros(new_shape, dtype=np.float64)
# 将已有的数据复制到新的 ndarray 中
extended_ndarray[:, : total_array.shape[1]] = total_array
total_array = extended_ndarray
else:
raise ValueError(f"传入的快照数组列数为{_array.shape[1]}，小于快照缓存的列数！")
total_array += _array * _build_up
effective_buildup += _build_up
self.current_effective_anomaly = effective_buildup
self.current_ndarray = total_array / self.current_effective_anomaly
self.settled = True
================================================
FILE: zsim/sim_progress/anomaly_bar/CopyAnomalyForOutput.py
================================================
import uuid
from typing import TYPE_CHECKING
from .AnomalyBarClass import AnomalyBar
if TYPE_CHECKING:
from zsim.simulator.simulator_class import Simulator
class Disorder(AnomalyBar):
"""
紊乱类，当这个类被创建，将会在__init__方法中自动调用__dict__方法，立刻复制父类的所有状态。
注意，语法上，在创建Disorder实例时，需要在括号里传入需要复制的父类实例。
Disorder会打开自身的is_disorder
"""
def __init__(self, Output_bar: AnomalyBar, sim_instance: "Simulator", **kwargs):
super().__init__(sim_instance=sim_instance)
self.__dict__.update(Output_bar.__dict__)
self.sim_instance = sim_instance
self.is_disorder = True
activate_by = kwargs.get("active_by", None)
self.activate_by = activate_by
# 复制父类的所有属性，主要是快照、积蓄总值、属性类型。
self.source_uuid = self.UUID
self.UUID = uuid.uuid4()
def __hash__(self):
"""使对象可哈希"""
return hash(self.UUID)
class NewAnomaly(AnomalyBar):
"""
普通的异常类，仅用于非紊乱的属性异常更新。
"""
def __init__(self, Output_bar: AnomalyBar, active_by, sim_instance: "Simulator"):
super().__init__(sim_instance=sim_instance)
self.__dict__.update(Output_bar.__dict__)
self.sim_instance = sim_instance
self.activate_by = active_by
self.source_uuid = self.UUID
self.UUID = uuid.uuid4()
def __hash__(self):
"""使对象可哈希"""
return hash(self.UUID)
class PolarityDisorder(Disorder):
"""
柳的极性紊乱（不含核心被动的紊乱基础倍率增加）
极性紊乱的计算公式为：
极性紊乱伤害 = 紊乱伤害 * 本次极性紊乱倍率（解锁2命后可变）+ 附加3200% * 精通的伤害
构造时，不仅需要提供被复制的异常条，还需要提供连击次数（用来计算极性紊乱比例），还需要提供触发者ID（CID或者enemy）
"""
def __init__(
self,
Output_bar: AnomalyBar,
_polarity_disorder_ratio,
active_by,
sim_instance: "Simulator",
):
super().__init__(Output_bar, active_by=active_by, sim_instance=sim_instance)
self.__dict__.update(Output_bar.__dict__)
self.sim_instance = sim_instance
self.is_disorder = True
self.polarity_disorder_ratio = (
_polarity_disorder_ratio # 极性紊乱对比紊乱的缩放比例（已经考虑连击次数）
)
self.additional_dmg_ap_ratio = 32 # 精通附加伤害的倍率！
self.activate_by = active_by
self.source_uuid = self.UUID
self.UUID = uuid.uuid4()
def __hash__(self):
"""使对象可哈希"""
return hash(self.UUID)
class DirgeOfDestinyAnomaly(AnomalyBar):
"""薇薇安的核心被动「命运悲歌」会重复触发一次异常伤害，
该伤害具有属性异常的全部相同参数，同时具有一个缩放倍率。"""
def __init__(self, Output_bar: AnomalyBar, active_by, sim_instance: "Simulator"):
super().__init__(sim_instance=sim_instance)
self.__dict__.update(Output_bar.__dict__)
self.sim_instance = sim_instance
self.activate_by = active_by
self.anomaly_dmg_ratio = 0 # 属性异常伤害的缩放倍率
self.source_uuid = self.UUID
self.UUID = uuid.uuid4()
def __hash__(self):
"""使对象可哈希"""
return hash(self.UUID)
================================================
FILE: zsim/sim_progress/anomaly_bar/__init__.py
================================================
from .Anomalies import (
AuricInkAnomaly,
ElectricAnomaly,
EtherAnomaly,
FireAnomaly,
FrostAnomaly,
IceAnomaly,
PhysicalAnomaly,
)
from .AnomalyBarClass import AnomalyBar
from .CopyAnomalyForOutput import Disorder
__all__ = [
"AnomalyBar",
"PhysicalAnomaly",
"FireAnomaly",
"IceAnomaly",
"ElectricAnomaly",
"EtherAnomaly",
"FrostAnomaly",
"Disorder",
"AuricInkAnomaly",
]
================================================
FILE: zsim/sim_progress/data_struct/ActionStack.cpp
================================================
#include "ActionStack.h"
// 构造函数
static int PyActionStack_init(PyActionStack* self, PyObject* args, PyObject* kwargs) {
self->action_stack = new ActionStack();
return 0;
}
// 析构函数
static void PyActionStack_dealloc(PyActionStack* self) {
delete self->action_stack;
Py_TYPE(self)->tp_free((PyObject*)self);
}
// 迭代器构造函数
static int PyActionStackIterator_init(PyActionStackIterator* self, PyObject* args, PyObject* kwargs) {
PyObject* action_stack_obj;
if (!PyArg_ParseTuple(args, "O!", &PyActionStackType, &action_stack_obj)) {
return -1;
}
self->iterator = new ActionStack::ActionStackIterator(((PyActionStack*)action_stack_obj)->action_stack);
return 0;
}
// 迭代器析构函数
static void PyActionStackIterator_dealloc(PyActionStackIterator* self) {
delete self->iterator;
Py_TYPE(self)->tp_free((PyObject*)self);
}
// push 方法
static PyObject* PyActionStack_push(PyActionStack* self, PyObject* args) {
PyObject* item;
if (!PyArg_ParseTuple(args, "O", &item)) {
return NULL;
}
self->action_stack->push(item);
Py_RETURN_NONE;
}
// pop 方法
static PyObject* PyActionStack_pop(PyActionStack* self, PyObject* args) {
try {
PyObject* result = self->action_stack->pop();
Py_INCREF(result);
return result;
} catch (const std::out_of_range& e) {
PyErr_SetString(PyExc_IndexError, e.what());
return NULL;
}
}
// peek 方法
static PyObject* PyActionStack_peek(PyActionStack* self, PyObject* args) {
try {
PyObject* result = self->action_stack->peek();
Py_INCREF(result);
return result;
} catch (const std::out_of_range& e) {
PyErr_SetString(PyExc_IndexError, e.what());
return NULL;
}
}
// is_empty 方法
static PyObject* PyActionStack_is_empty(PyActionStack* self, PyObject* args) {
return Py_BuildValue("b", self->action_stack->is_empty());
}
// peek_bottom 方法
static PyObject* PyActionStack_peek_bottom(PyActionStack* self, PyObject* args) {
try {
PyObject* result = self->action_stack->peek_bottom();
Py_INCREF(result);
return result;
} catch (const std::out_of_range& e) {
PyErr_SetString(PyExc_IndexError, e.what());
return NULL;
}
}
// size 方法
static PyObject* PyActionStack_size(PyActionStack* self, PyObject* args) {
return Py_BuildValue("n", self->action_stack->size());
}
// to_string 方法
static PyObject* PyActionStack_to_string(PyActionStack* self, PyObject* args) {
std::string result = self->action_stack->to_string();
return Py_BuildValue("s", result.c_str());
}
// __getitem__ 方法
static PyObject* PyActionStack_getitem(PyActionStack* self, PyObject* args) {
Py_ssize_t index;
if (!PyArg_ParseTuple(args, "n", &index)) {
return NULL;
}
try {
PyObject* result = self->action_stack->operator[](index);
Py_INCREF(result);
return result;
} catch (const std::out_of_range& e) {
PyErr_SetString(PyExc_IndexError, e.what());
return NULL;
}
}
// __eq__ 方法
static PyObject* PyActionStack_eq(PyActionStack* self, PyObject* other) {
if (!PyObject_TypeCheck(other, &PyActionStackType)) {
Py_RETURN_FALSE;
}
PyActionStack* other_stack = (PyActionStack*)other;
return Py_BuildValue("b", *self->action_stack == *other_stack->action_stack);
}
// __ne__ 方法
static PyObject* PyActionStack_ne(PyActionStack* self, PyObject* other) {
if (!PyObject_TypeCheck(other, &PyActionStackType)) {
Py_RETURN_TRUE;
}
PyActionStack* other_stack = (PyActionStack*)other;
return Py_BuildValue("b", *self->action_stack != *other_stack->action_stack);
}
// __iter__ 方法
static PyObject* PyActionStack_iter(PyActionStack* self) {
PyActionStackIterator* iterator = (PyActionStackIterator*)PyObject_New(PyActionStackIterator, &PyActionStackIteratorType);
if (iterator == NULL) {
return NULL;
}
if (PyActionStackIterator_init(iterator, (PyObject*)self, NULL) < 0) {
Py_DECREF(iterator);
return NULL;
}
return (PyObject*)iterator;
}
// 迭代器 __next__ 方法
static PyObject* PyActionStackIterator_next(PyActionStackIterator* self) {
return self->iterator->next();
}
// 类型定义
PyTypeObject PyActionStackType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ActionStack.ActionStack", // tp_name
sizeof(PyActionStack), // tp_basicsize
0, // tp_itemsize
(destructor)PyActionStack_dealloc, // tp_dealloc
0, // tp_print
0, // tp_getattr
0, // tp_setattr
0, // tp_reserved
0, // tp_repr
0, // tp_as_number
0, // tp_as_sequence
0, // tp_as_mapping
0, // tp_hash
0, // tp_call
0, // tp_str
0, // tp_getattro
0, // tp_setattro
0, // tp_as_buffer
Py_TPFLAGS_DEFAULT, // tp_flags
"A simple action stack.", // tp_doc
0, // tp_traverse
0, // tp_clear
0, // tp_richcompare
0, // tp_weaklistoffset
0, // tp_iter
0, // tp_iternext
PyActionStack_methods, // tp_methods
0, // tp_members
0, // tp_getset
0, // tp_base
0, // tp_dict
0, // tp_descr_get
0, // tp_descr_set
0, // tp_dictoffset
(initproc)PyActionStack_init, // tp_init
0, // tp_alloc
PyType_GenericNew, // tp_new
};
// 迭代器类型定义
PyTypeObject PyActionStackIteratorType = {
PyVarObject_HEAD_INIT(NULL, 0)
"ActionStack.ActionStackIterator", // tp_name
sizeof(PyActionStackIterator), // tp_basicsize
0, // tp_itemsize
(destructor)PyActionStackIterator_dealloc, // tp_dealloc
0, // tp_print
0, // tp_getattr
0, // tp_setattr
0, // tp_reserved
0, // tp_repr
0, // tp_as_number
0, // tp_as_sequence
0, // tp_as_mapping
0, // tp_hash
0, // tp_call
0, // tp_str
0, // tp_getattro
0, // tp_setattro
0, // tp_as_buffer
Py_TPFLAGS_DEFAULT, // tp_flags
"ActionStack iterator object", // tp_doc
0, // tp_traverse
0, // tp_clear
0, // tp_richcompare
0, // tp_weaklistoffset
PyObject_SelfIter, // tp_iter
(iternextfunc)PyActionStackIterator_next, // tp_iternext
PyActionStackIterator_methods, // tp_methods
0, // tp_members
0, // tp_getset
0, // tp_base
0, // tp_dict
0, // tp_descr_get
0, // tp_descr_set
0, // tp_dictoffset
(initproc)PyActionStackIterator_init, // tp_init
0, // tp_alloc
PyType_GenericNew, // tp_new
};
// 模块初始化
static PyModuleDef ActionStackModule = {
PyModuleDef_HEAD_INIT,
"ActionStack",
"A simple action stack module.",
-1,
NULL, NULL, NULL, NULL, NULL
};
PyMODINIT_FUNC PyInit_ActionStack(void) {
PyObject* m;
if (PyType_Ready(&PyActionStackType) < 0) {
return NULL;
}
if (PyType_Ready(&PyActionStackIteratorType) < 0) {
return NULL;
}
m = PyModule_Create(&ActionStackModule);
if (m == NULL) {
return NULL;
}
Py_INCREF(&PyActionStackType);
if (PyModule_AddObject(m, "ActionStack", (PyObject*)&PyActionStackType) < 0) {
Py_DECREF(&PyActionStackType);
Py_DECREF(m);
return NULL;
}
return m;
}
================================================
FILE: zsim/sim_progress/data_struct/ActionStack.h
================================================
#ifndef ACTIONSTACK_H
#define ACTIONSTACK_H
#define PY_SSIZE_T_CLEAN
#include