fz-mirrors/MaaAssistantArknights
0
0
Fork 0
mirror of https://github.com/MaaAssistantArknights/MaaAssistantArknights.git synced 2026-07-17 10:00:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

perf: 简化肉鸽Config和部分设置 (#9822)

Browse Source
This commit is contained in:
status102
2024-07-22 08:21:54 +08:00
committed by GitHub
parent d3d4a4a382 1d777a7234
commit c8cf8579aa
5 changed files with 121 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/MaaCore/Task/Interface/RoguelikeTask.cpp
View File

@@ -80,7 +80,8 @@ asst::RoguelikeTask::RoguelikeTask(const AsstCallback& callback, Assistant* inst
m_roguelike_task_ptr->register_plugin<RoguelikeFoldartalGainTaskPlugin>(m_config_ptr);
m_roguelike_task_ptr->register_plugin<RoguelikeFoldartalUseTaskPlugin>(m_config_ptr);
m_roguelike_task_ptr->register_plugin<RoguelikeFoldartalStartTaskPlugin>(m_config_ptr);
m_roguelike_task_ptr->register_plugin<RoguelikeCollapsalParadigmTaskPlugin>(m_config_ptr);
m_cp_ptr = m_roguelike_task_ptr->register_plugin<RoguelikeCollapsalParadigmTaskPlugin>(
m_config_ptr);
// 这个任务如果卡住会放弃当前的肉鸽并重新开始，所以多添加亿点。先这样凑合用
for (int i = 0; i != 999; ++i) {
@@ -220,13 +221,9 @@ bool asst::RoguelikeTask::set_params(const json::value& params)
// 是否检查坍缩范式，非CLP_PDS模式下默认为False, CLP_PDS模式下默认为True
m_config_ptr->set_check_clp_pds(
params.get("check_collapsal_paradigms", mode == RoguelikeMode::CLP_PDS));
m_config_ptr->set_double_check_clp_pds(
m_cp_ptr->set_double_check_clp_pds(
params.get("double_check_collapsal_paradigms", mode == RoguelikeMode::CLP_PDS));
const std::unordered_set<std::string>& rare_clp_pds =
RoguelikeCollapsalParadigms.get_rare_clp_pds(theme);
m_config_ptr->set_expected_clp_pds(
params.get("expected_collapsal_paradigms", rare_clp_pds));
}
const auto& ptr = m_custom_ptr;

3
src/MaaCore/Task/Interface/RoguelikeTask.h
View File

@@ -8,6 +8,7 @@ namespace asst
class RoguelikeInvestTaskPlugin;
class RoguelikeDebugTaskPlugin;
class RoguelikeCustomStartTaskPlugin;
class RoguelikeCollapsalParadigmTaskPlugin;
class RoguelikeTask : public InterfaceTask
{
@@ -25,6 +26,6 @@ namespace asst
std::shared_ptr<RoguelikeInvestTaskPlugin> m_invest_ptr = nullptr;
std::shared_ptr<RoguelikeDebugTaskPlugin> m_debug_ptr = nullptr;
std::shared_ptr<RoguelikeCustomStartTaskPlugin> m_custom_ptr = nullptr;
std::shared_ptr<RoguelikeCollapsalParadigmTaskPlugin> m_cp_ptr = nullptr;
};
}

8
src/MaaCore/Task/Roguelike/RoguelikeConfig.h
View File

@@ -107,10 +107,6 @@ namespace asst
// ------------------ 坍缩范式 ------------------
void set_check_clp_pds(bool value) { m_check_clp_pds = value; }
bool get_check_clp_pds() const { return m_check_clp_pds; }
void set_double_check_clp_pds(bool value) { m_double_check_clp_pds = value; }
bool get_double_check_clp_pds() const { return m_double_check_clp_pds; }
void set_expected_clp_pds(std::unordered_set<std::string> value) { m_expected_clp_pds = value; }
std::unordered_set<std::string> get_expected_clp_pds() const { return m_expected_clp_pds; }
private:
// ------------------ 密文板 ------------------
@@ -121,9 +117,7 @@ namespace asst
bool m_use_foldartal = true; // 是否使用密文板
// ------------------ 坍缩范式 ------------------
bool m_check_clp_pds = false; // 是否检查坍缩范式
bool m_double_check_clp_pds = false; // 是否反复检查坍缩范式
std::unordered_set<std::string> m_expected_clp_pds; // 期望获得坍缩范式
bool m_check_clp_pds = false; // 是否检查坍缩范式
/* 以下为局内数据，每次重置 */

112
src/MaaCore/Task/Roguelike/Sami/RoguelikeCollapsalParadigmTaskPlugin.cpp
View File

@@ -5,8 +5,8 @@
#include "Controller/Controller.h"
#include "Task/ProcessTask.h"
#include "Utils/Logger.hpp"
#include "Vision/OCRer.h"
#include "Vision/Matcher.h"
#include "Vision/OCRer.h"
#include <algorithm>
@@ -45,7 +45,8 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::verify(
const AsstMsg msg,
const json::value& details) const
{
if ((msg != AsstMsg::SubTaskStart && msg != AsstMsg::SubTaskCompleted) || details.get("subtask", std::string()) != "ProcessTask") {
if ((msg != AsstMsg::SubTaskStart && msg != AsstMsg::SubTaskCompleted)
|| details.get("subtask", std::string()) != "ProcessTask") {
return false;
}
@@ -54,37 +55,40 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::verify(
return false;
}
if (m_config->get_theme() != RoguelikeTheme::Sami || !m_config->get_check_clp_pds()) {
if (m_config->get_theme() != RoguelikeTheme::Sami || !m_config->get_check_clp_pds()) {
return false;
}
const auto task_name = details.get("details", "task", "");
if (msg == AsstMsg::SubTaskStart && m_banner_triggers_start.find(task_name) != m_banner_triggers_start.end()) {
if (msg == AsstMsg::SubTaskStart
&& m_banner_triggers_start.find(task_name) != m_banner_triggers_start.end()) {
m_check_banner = true;
return true;
}
if (msg == AsstMsg::SubTaskCompleted && m_banner_triggers_completed.find(task_name) != m_banner_triggers_completed.end()) {
if (msg == AsstMsg::SubTaskCompleted
&& m_banner_triggers_completed.find(task_name) != m_banner_triggers_completed.end()) {
m_check_banner = true;
return true;
}
if(msg == AsstMsg::SubTaskStart && m_panel_triggers.find(task_name) != m_panel_triggers.end()) {
if (msg == AsstMsg::SubTaskStart
&& m_panel_triggers.find(task_name) != m_panel_triggers.end()) {
if (new_zone()) {
m_config->set_need_check_panel(true);
m_verification_check = false;
}
if (m_config->get_need_check_panel()) {
m_config->set_need_check_panel(false);
m_check_panel = true;
return true;
}
}
if (!m_config->get_need_check_panel() && m_config->get_double_check_clp_pds() && msg == AsstMsg::SubTaskCompleted
&& m_panel_triggers.find(task_name) == m_panel_triggers.end()) {
if (msg == AsstMsg::SubTaskCompleted && !m_config->get_need_check_panel()
&& m_double_check_clp_pds && m_panel_triggers.find(task_name) == m_panel_triggers.end()) {
m_config->set_need_check_panel(true);
m_verification_check = true;
};
@@ -130,45 +134,56 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_banner
detected = analyzer1.analyze();
}
if (detected) {
const std::vector<CollapsalParadigmClass>& clp_pd_classes = RoguelikeCollapsalParadigms.get_clp_pd_classes(theme);
const std::unordered_map<std::string, unsigned int>& clp_pd_dict = RoguelikeCollapsalParadigms.get_clp_pd_dict(theme);
const std::unordered_set<std::string>& expected_clp_pds = m_config->get_expected_clp_pds();
const std::vector<CollapsalParadigmClass>& clp_pd_classes =
RoguelikeCollapsalParadigms.get_clp_pd_classes(theme);
const std::unordered_map<std::string, unsigned int>& clp_pd_dict =
RoguelikeCollapsalParadigms.get_clp_pd_dict(theme);
const auto& expected_clp_pds = RoguelikeCollapsalParadigms.get_rare_clp_pds(theme);
std::vector<std::string> prev_clp_pds = m_config->get_clp_pds();
OCRer analyzer2(image); // 检测坍缩范式
analyzer2.set_task_info(theme + "@Roguelike@CheckCollapsalParadigms_banner");
if (!analyzer2.analyze()) {
Log.info("Roguelike Collapsal Paradigm Task Plugin: Erroneous Recognition in Banner Check");
Log.info(
"Roguelike Collapsal Paradigm Task Plugin: Erroneous Recognition in Banner Check");
return false;
}
OCRer::ResultsVec ocr_results1 = analyzer1.get_result();
std::sort(ocr_results1.begin(), ocr_results1.end(), m_compare);
OCRer::ResultsVec ocr_results2 = analyzer2.get_result();
std::sort(ocr_results2.begin(), ocr_results2.end(), m_compare);
sort_by_vertical_(ocr_results1); // 按照水平方向排序(从左到右
sort_by_vertical_(ocr_results2); // 按照水平方向排序(从左到右
OCRer::ResultsVec::iterator result_it1 = ocr_results1.begin();
OCRer::ResultsVec::iterator result_it2 = ocr_results2.begin();
std::vector<std::string>::iterator it;
while (result_it1 != ocr_results1.end() && result_it2 != ocr_results2.end()) {
if ((*result_it2).rect.y >= (*result_it1).rect.y + (*result_it1).rect.height + 25) {
Log.info("Roguelike Collapsal Paradigm Task Plugin: Erroneous Recognition in Banner Check");
Log.info(
"Roguelike Collapsal Paradigm Task Plugin: Erroneous Recognition in Banner "
"Check");
++result_it1;
continue;
}
else if ((*result_it2).rect.y <= (*result_it1).rect.y) {
Log.info("Roguelike Collapsal Paradigm Task Plugin: Erroneous Recognition in Banner Check");
Log.info(
"Roguelike Collapsal Paradigm Task Plugin: Erroneous Recognition in Banner "
"Check");
++result_it2;
continue;
}
std::string cur_clp_pd = (*result_it2).text;
const CollapsalParadigmClass& cur_class = clp_pd_classes.at(clp_pd_dict.at(cur_clp_pd));
if ((*result_it1).text == m_deepen_text) {
if (it = std::find(prev_clp_pds.begin(), prev_clp_pds.end(), cur_clp_pd); it == prev_clp_pds.end()) {
if (it = std::find(prev_clp_pds.begin(), prev_clp_pds.end(), cur_clp_pd);
it == prev_clp_pds.end()) {
if (cur_clp_pd == cur_class.level_2) {
if (it = std::find(prev_clp_pds.begin(), prev_clp_pds.end(), cur_class.level_1); it != prev_clp_pds.end()) {
if (it = std::find(
prev_clp_pds.begin(),
prev_clp_pds.end(),
cur_class.level_1);
it != prev_clp_pds.end()) {
clp_pd_callback(cur_clp_pd, 1, *it);
*it = cur_clp_pd;
}
@@ -187,14 +202,17 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_banner
exit_then_stop();
return true;
}
else if (m_config->get_mode() == RoguelikeMode::CLP_PDS) { // 刷坍缩范式模式下，获得了不想要的坍缩范式
else if (
m_config->get_mode()
== RoguelikeMode::CLP_PDS) { // 刷坍缩范式模式下，获得了不想要的坍缩范式
exit_then_restart();
return true;
}
}
}
else {
if (it = std::find(prev_clp_pds.begin(), prev_clp_pds.end(), cur_clp_pd); it != prev_clp_pds.end()) {
if (it = std::find(prev_clp_pds.begin(), prev_clp_pds.end(), cur_clp_pd);
it != prev_clp_pds.end()) {
if (cur_clp_pd == cur_class.level_2) {
clp_pd_callback(cur_class.level_1, -1, cur_clp_pd);
*it = cur_class.level_1;
@@ -216,7 +234,7 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_banner
}
bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_panel()
{
{
LogTraceFunction;
#ifdef ASST_DEBUG
@@ -227,16 +245,19 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_panel(
const std::string& theme = m_config->get_theme();
const std::vector<CollapsalParadigmClass>& clp_pd_classes = RoguelikeCollapsalParadigms.get_clp_pd_classes(theme);
const std::unordered_map<std::string, unsigned int>& clp_pd_dict = RoguelikeCollapsalParadigms.get_clp_pd_dict(theme);
const std::unordered_set<std::string>& expected_clp_pds = m_config->get_expected_clp_pds();
const std::vector<CollapsalParadigmClass>& clp_pd_classes =
RoguelikeCollapsalParadigms.get_clp_pd_classes(theme);
const std::unordered_map<std::string, unsigned int>& clp_pd_dict =
RoguelikeCollapsalParadigms.get_clp_pd_dict(theme);
const auto& expected_clp_pds = RoguelikeCollapsalParadigms.get_rare_clp_pds(theme);
std::vector<std::string> prev_clp_pds = m_config->get_clp_pds();
wait_for_stage(200);
cv::Mat image;
OCRer analyzer;
analyzer.set_task_info(theme + "@Roguelike@CheckCollapsalParadigms_onPanel"); // 检测 "当前坍缩值" 字样
analyzer.set_task_info(
theme + "@Roguelike@CheckCollapsalParadigms_onPanel"); // 检测 "当前坍缩值" 字样
do {
toggle_collapsal_status_panel();
image = ctrler()->get_image();
@@ -264,23 +285,25 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_panel(
ocr_results = analyzer.get_result();
}
}
std::sort(ocr_results.begin(), ocr_results.end(), m_compare);
std::transform(ocr_results.begin(), ocr_results.end(),
sort_by_vertical_(ocr_results); // 按照水平方向排序(从左到右
std::transform(
ocr_results.begin(),
ocr_results.end(),
std::back_inserter(cur_clp_pds),
[](OCRer::Result x) { return x.text; });
}
if (m_verification_check) {
if (prev_clp_pds != cur_clp_pds) {
Log.info("Roguelike Collapsal Paradigm Task Plugin: Verification Failed");
#ifdef ASST_DEBUG
Log.info("–––––––– Previous ––––––––––––––");
for (const std::string& clp_pd: prev_clp_pds) {
for (const std::string& clp_pd : prev_clp_pds) {
Log.info(clp_pd);
}
Log.info("–––––––– Current –––––––––––––––");
for (const std::string& clp_pd: cur_clp_pds) {
for (const std::string& clp_pd : cur_clp_pds) {
Log.info(clp_pd);
}
#endif
@@ -302,11 +325,13 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_panel(
}
if (it == prev_clp_pds.end()) { // 全新的坍缩范式
clp_pd_callback(cur_clp_pd, 1);
} else {
}
else {
if (cur_clp_pd == cur_class.level_2 && *it == cur_class.level_1) { // 从1级加深到2级
clp_pd_callback(cur_clp_pd, 1, cur_class.level_1);
} else if (cur_clp_pd == cur_class.level_1 && *it == cur_class.level_2) { // 从2级消退到1级
}
else if (
cur_clp_pd == cur_class.level_1 && *it == cur_class.level_2) { // 从2级消退到1级
clp_pd_callback(cur_clp_pd, -1, cur_class.level_2);
}
++it;
@@ -318,7 +343,9 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_panel(
exit_then_stop();
return true;
}
else if (m_config->get_mode() == RoguelikeMode::CLP_PDS) { // 刷坍缩范式模式下，获得了不想要的坍缩范式
else if (
m_config->get_mode()
== RoguelikeMode::CLP_PDS) { // 刷坍缩范式模式下，获得了不想要的坍缩范式
toggle_collapsal_status_panel();
exit_then_restart();
return true;
@@ -330,7 +357,7 @@ bool asst::RoguelikeCollapsalParadigmTaskPlugin::check_collapsal_paradigm_panel(
}
m_config->set_clp_pds(std::move(cur_clp_pds));
toggle_collapsal_status_panel();
return true;
}
@@ -350,7 +377,10 @@ void asst::RoguelikeCollapsalParadigmTaskPlugin::exit_then_restart()
.run();
}
void asst::RoguelikeCollapsalParadigmTaskPlugin::clp_pd_callback(std::string cur, int deepen_or_weaken, std::string prev)
void asst::RoguelikeCollapsalParadigmTaskPlugin::clp_pd_callback(
std::string cur,
int deepen_or_weaken,
std::string prev)
{
json::value info = basic_info_with_what("RoguelikeCollapsalParadigms");
info["details"]["cur"] = cur;

90
src/MaaCore/Task/Roguelike/Sami/RoguelikeCollapsalParadigmTaskPlugin.h
View File

@@ -1,68 +1,66 @@
#pragma once
#include "../AbstractRoguelikeTaskPlugin.h"
#include "Common/AsstTypes.h"
#include "Vision/OCRer.h"
#include "Config/TaskData.h"
#include "Vision/OCRer.h"
namespace asst
{
class RoguelikeCollapsalParadigmTaskPlugin : public AbstractRoguelikeTaskPlugin
class RoguelikeCollapsalParadigmTaskPlugin : public AbstractRoguelikeTaskPlugin
{
public:
RoguelikeCollapsalParadigmTaskPlugin(
const AsstCallback& callback,
Assistant* inst,
std::string_view task_chain,
std::shared_ptr<RoguelikeConfig> config);
// using AbstractRoguelikeTaskPlugin::AbstractRoguelikeTaskPlugin;
virtual ~RoguelikeCollapsalParadigmTaskPlugin() override = default;
virtual bool verify(AsstMsg msg, const json::value& details) const override;
static bool enabled(std::shared_ptr<RoguelikeConfig> config)
{
public:
RoguelikeCollapsalParadigmTaskPlugin(
const AsstCallback& callback,
Assistant* inst,
std::string_view task_chain,
std::shared_ptr<RoguelikeConfig> config);
// using AbstractRoguelikeTaskPlugin::AbstractRoguelikeTaskPlugin;
virtual ~RoguelikeCollapsalParadigmTaskPlugin() override = default;
return config->get_theme() == RoguelikeTheme::Sami && config->get_check_clp_pds();
}
static bool enabled(std::shared_ptr<RoguelikeConfig> config) {
return config->get_theme() == RoguelikeTheme::Sami && config->get_check_clp_pds();
}
public:
void set_double_check_clp_pds(bool value) { m_double_check_clp_pds = value; }
bool check_collapsal_paradigm_banner();
public:
virtual bool verify(AsstMsg msg, const json::value& details) const override;
protected:
virtual bool _run() override;
bool check_collapsal_paradigm_banner();
bool new_zone() const;
protected:
virtual bool _run() override;
bool check_collapsal_paradigm_panel();
private:
mutable bool m_check_banner = false;
mutable bool m_check_panel = false;
mutable bool m_verification_check = false;
void toggle_collapsal_status_panel();
void exit_then_restart();
void exit_then_stop();
void wait_for_loading(unsigned int millisecond = 0);
void wait_for_stage(unsigned int millisecond = 0);
void clp_pd_callback(std::string cur, int deepen_or_weaken = 0, std::string prev = "");
std::string m_deepen_text;
private:
mutable bool m_check_banner = false;
mutable bool m_check_panel = false;
mutable bool m_verification_check = false;
std::unordered_set<std::string> m_banner_triggers_start;
std::string m_deepen_text;
std::unordered_set<std::string> m_banner_triggers_completed;
std::unordered_set<std::string> m_banner_triggers_start;
mutable std::string m_zone;
std::unordered_set<std::string> m_banner_triggers_completed;
Rect m_roi; // 屏幕上方居中区域，点击以检查坍缩状态
Point m_swipe_begin; // 滑动起点
Point m_swipe_end; // 滑动终点
mutable std::string m_zone;
std::unordered_set<std::string> m_panel_triggers;
Rect m_roi; // 屏幕上方居中区域，点击以检查坍缩状态
Point m_swipe_begin; // 滑动起点
Point m_swipe_end; // 滑动终点
std::unordered_map<std::string, std::string> m_zone_dict;
std::unordered_set<std::string> m_panel_triggers;
std::unordered_map<std::string, std::string> m_zone_dict;
std::function<bool(const OCRer::Result&, const OCRer::Result&)> m_compare =
[](const OCRer::Result& x1, const OCRer::Result& x2){ return x1.rect.y < x2.rect.y; };
bool new_zone() const;
bool check_collapsal_paradigm_panel();
void toggle_collapsal_status_panel();
void exit_then_restart();
void exit_then_stop();
void wait_for_loading(unsigned int millisecond = 0);
void wait_for_stage(unsigned int millisecond = 0);
void clp_pd_callback(std::string cur, int deepen_or_weaken = 0, std::string prev = "");
};
bool m_double_check_clp_pds = false; // 是否反复检查坍缩范式
};
}