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

refactor.删除实例化的TaskData

Browse Source
This commit is contained in:
MistEO
2022-03-09 23:40:28 +08:00
parent 50ccafdf44
commit e3b2401ca6
39 changed files with 144 additions and 367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/AsstCaller.h
View File

@@ -28,8 +28,6 @@ extern "C" {
bool ASSTAPI AsstStart(AsstHandle handle);
bool ASSTAPI AsstStop(AsstHandle handle);
bool ASSTAPI AsstSetParam(AsstHandle handle, const char* param_id, const char* param_value);
unsigned long long ASSTAPI AsstGetImage(AsstHandle handle, void* buff, unsigned long long buff_size);
bool ASSTAPI AsstCtrlerClick(AsstHandle handle, int x, int y, bool block);

14
src/MeoAssistant/AbstractImageAnalyzer.cpp
View File

@@ -11,15 +11,6 @@ asst::AbstractImageAnalyzer::AbstractImageAnalyzer(const cv::Mat image)
#endif
{}
asst::AbstractImageAnalyzer::AbstractImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
: m_image(image), m_roi(empty_rect_to_full(Rect(), image)),
m_task_data(task_data)
#ifdef ASST_DEBUG
,
m_image_draw(image.clone())
#endif
{}
asst::AbstractImageAnalyzer::AbstractImageAnalyzer(const cv::Mat image, const Rect& roi)
: m_image(image),
m_roi(empty_rect_to_full(roi, image))
@@ -50,11 +41,6 @@ void asst::AbstractImageAnalyzer::set_roi(const Rect& roi) noexcept
m_roi = empty_rect_to_full(roi, m_image);
}
void asst::AbstractImageAnalyzer::set_task_data(std::shared_ptr<TaskData> task_data)
{
m_task_data = task_data;
}
asst::Rect asst::AbstractImageAnalyzer::empty_rect_to_full(const Rect& rect, const cv::Mat image) noexcept
{
return rect.empty() ? Rect(0, 0, image.cols, image.rows) : rect;

2
src/MeoAssistant/AbstractImageAnalyzer.h
View File

@@ -12,7 +12,6 @@ namespace asst
public:
AbstractImageAnalyzer() = default;
AbstractImageAnalyzer(const cv::Mat image);
AbstractImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
AbstractImageAnalyzer(const cv::Mat image, const Rect& roi);
AbstractImageAnalyzer(const AbstractImageAnalyzer&) = delete;
AbstractImageAnalyzer(AbstractImageAnalyzer&&) = delete;
@@ -33,7 +32,6 @@ namespace asst
cv::Mat m_image;
Rect m_roi;
std::shared_ptr<TaskData> m_task_data = nullptr;
#ifdef ASST_DEBUG
cv::Mat m_image_draw;

9
src/MeoAssistant/AbstractTask.cpp
View File

@@ -70,12 +70,6 @@ AbstractTask& asst::AbstractTask::set_status(std::shared_ptr<RuntimeStatus> stat
return *this;
}
AbstractTask& asst::AbstractTask::set_task_data(std::shared_ptr<TaskData> task_data) noexcept
{
m_task_data = task_data;
return *this;
}
void asst::AbstractTask::clear_plugin() noexcept
{
m_plugins.clear();
@@ -162,7 +156,6 @@ void asst::AbstractTask::callback(AsstMsg msg, const json::value& detail)
plugin->set_exit_flag(m_exit_flag);
plugin->set_ctrler(m_ctrler);
plugin->set_status(m_status);
plugin->set_task_data(m_task_data);
plugin->set_task_ptr(this);
if (!plugin->verify(msg, detail)) {
@@ -181,7 +174,7 @@ void asst::AbstractTask::callback(AsstMsg msg, const json::value& detail)
void asst::AbstractTask::click_return_button()
{
LogTraceFunction;
const auto return_task_ptr = m_task_data->get("Return");
const auto return_task_ptr = Task.get("Return");
Rect ReturnButtonRect = return_task_ptr->specific_rect;

2
src/MeoAssistant/AbstractTask.h
View File

@@ -35,7 +35,6 @@ namespace asst
virtual AbstractTask& set_retry_times(int times) noexcept;
virtual AbstractTask& set_ctrler(std::shared_ptr<Controller> ctrler) noexcept;
virtual AbstractTask& set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
virtual AbstractTask& set_task_data(std::shared_ptr<TaskData> task_data) noexcept;
template<typename PluginType>
std::shared_ptr<PluginType> regiseter_plugin()
@@ -75,6 +74,5 @@ namespace asst
std::set<TaskPluginPtr> m_plugins;
std::shared_ptr<Controller> m_ctrler = nullptr;
std::shared_ptr<RuntimeStatus> m_status = nullptr;
std::shared_ptr<TaskData> m_task_data = nullptr;
};
}

72
src/MeoAssistant/Assistant.cpp
View File

@@ -27,7 +27,6 @@ Assistant::Assistant(AsstApiCallback callback, void* callback_arg)
LogTraceFunction;
m_status = std::make_shared<RuntimeStatus>();
m_task_data = std::make_shared<TaskData>();
m_ctrler = std::make_shared<Controller>(task_callback, (void*)this);
m_working_thread = std::thread(&Assistant::working_proc, this);
@@ -148,35 +147,6 @@ bool asst::Assistant::ctrler_click(int x, int y, bool block)
return true;
}
bool asst::Assistant::set_param(const std::string& param_id, const std::string& param_value)
{
Log.info(__FUNCTION__, param_id, param_value);
using SetParamFuncType = std::function<bool(const json::value&)>;
static const std::unordered_map<std::string, SetParamFuncType> ParamsMapping = {
{AsstParamIdPenguinId, std::bind(&Assistant::set_penguid_id, this, std::placeholders::_1)},
{AsstParamIdOcrText, std::bind(&Assistant::set_ocr_text, this, std::placeholders::_1)},
};
if (const auto iter = ParamsMapping.find(param_id);
iter != ParamsMapping.cend()) {
const auto& json_opt = json::parse(param_value);
if (!json_opt) {
Log.error("Param Value Parsing Failed", param_value);
return false;
}
const auto& root = json_opt.value();
std::unique_lock<std::mutex> lock(m_mutex);
return iter->second(root);
}
else {
Log.error("Invaild Param Id", param_id);
return false;
}
}
bool asst::Assistant::start(bool block)
{
LogTraceFunction;
@@ -233,8 +203,7 @@ void Assistant::working_proc()
task_ptr->set_exit_flag(&m_thread_idle)
.set_ctrler(m_ctrler)
.set_status(m_status)
.set_task_data(m_task_data);
.set_status(m_status);
bool ret = task_ptr->run();
@@ -321,42 +290,3 @@ void Assistant::clear_cache()
m_status->clear_data();
//Task.clear_cache();
}
bool asst::Assistant::set_penguid_id(const json::value& root)
{
if (!(root.is_object() && root.contains("id") && root.at("id").is_string())) {
Log.error("Json Field error");
return false;
}
auto& param = Resrc.cfg().get_options().penguin_report.extra_param;
std::string id = root.at("id").as_string();
if (id.empty()) {
param.clear();
}
else {
param = "-H \"authorization: PenguinID " + id + "\"";
}
return true;
}
bool asst::Assistant::set_ocr_text(const json::value& root)
{
bool ret = true;
for (auto&& [key, text_arr] : root.as_object()) {
if (!text_arr.is_array()) {
Log.error("Json Field error");
return false;
}
std::vector<std::string> text_vec;
for (auto&& text : text_arr.as_array()) {
if (!text.is_string()) {
Log.error("Json Field error");
return false;
}
text_vec.emplace_back(text.as_string());
}
ret &= m_task_data->set_ocr_text(key, std::move(text_vec));
}
return ret;
}

20
src/MeoAssistant/Assistant.h
View File

@@ -3,15 +3,11 @@
#include <condition_variable>
#include <memory>
#include <mutex>
#include <optional>
#include <queue>
#include <thread>
#include <unordered_map>
#include "AbstractTask.h"
#include "AsstTypes.h"
#include "AsstMsg.h"
#include "AsstInfrastDef.h"
typedef unsigned char uchar;
@@ -23,10 +19,8 @@ namespace cv
namespace asst
{
class Controller;
class Identify;
class Controller;
class TaskData;
class PackageTask;
class RuntimeStatus;
class Assistant
{
@@ -50,31 +44,19 @@ namespace asst
std::vector<uchar> get_image() const;
bool ctrler_click(int x, int y, bool block = true);
bool set_param(const std::string& param_id, const std::string& param_value);
static constexpr int ProcessTaskRetryTimesDefault = AbstractTask::RetryTimesDefault;
static constexpr int OpenRecruitTaskRetryTimesDefault = 5;
static constexpr int AutoRecruitTaskRetryTimesDefault = 5;
private:
void working_proc();
void msg_proc();
static void task_callback(AsstMsg msg, const json::value& detail, void* custom_arg);
bool append_process_task(const std::string& task_name, std::string task_chain = std::string(), int retry_times = ProcessTaskRetryTimesDefault);
void append_callback(AsstMsg msg, json::value detail);
void clear_cache();
/* set params */
bool set_penguid_id(const json::value& root);
bool set_ocr_text(const json::value& root);
bool m_inited = false;
std::string m_uuid;
std::shared_ptr<Controller> m_ctrler = nullptr;
std::shared_ptr<RuntimeStatus> m_status = nullptr;
std::shared_ptr<TaskData> m_task_data = nullptr;
bool m_thread_exit = false;
std::list<std::pair<int, std::shared_ptr<PackageTask>>> m_tasks_list;

17
src/MeoAssistant/AsstCaller.cpp
View File

@@ -97,15 +97,6 @@ bool AsstStop(AsstHandle handle)
return handle->stop();
}
bool AsstSetParam(AsstHandle handle, const char* param_id, const char* param_value)
{
if (!inited || handle == nullptr) {
return false;
}
return handle->set_param(param_id, param_value);
}
TaskId AsstAppendTask(AsstHandle handle, const char* type, const char* params)
{
if (!inited || handle == nullptr) {
@@ -115,14 +106,6 @@ TaskId AsstAppendTask(AsstHandle handle, const char* type, const char* params)
return handle->append_task(type, params);
}
bool AsstSetTaskParams(AsstHandle handle, TaskId id, const char* params)
{
if (!inited || handle == nullptr) {
return false;
}
return handle->set_task_params(id, params);
}
unsigned long long AsstGetImage(AsstHandle handle, void* buff, unsigned long long buff_size)
{
if (!inited || handle == nullptr || buff == nullptr) {

3
src/MeoAssistant/AutoRecruitTask.cpp
View File

@@ -80,8 +80,7 @@ bool asst::AutoRecruitTask::_run()
bool asst::AutoRecruitTask::analyze_start_buttons()
{
OcrImageAnalyzer start_analyzer;
start_analyzer.set_task_info(m_task_data->get("StartRecruit"));
start_analyzer.set_task_data(m_task_data);
start_analyzer.set_task_info(Task.get("StartRecruit"));
auto image = m_ctrler->get_image();
start_analyzer.set_image(image);

46
src/MeoAssistant/BattleImageAnalyzer.cpp
View File

@@ -8,10 +8,6 @@
#include "Logger.hpp"
#include "TaskData.h"
asst::BattleImageAnalyzer::BattleImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
: AbstractImageAnalyzer(image, task_data)
{}
bool asst::BattleImageAnalyzer::analyze()
{
// 生命值和家门，只要识别到了任一个，就可以说明当前是在战斗场景
@@ -50,17 +46,16 @@ bool asst::BattleImageAnalyzer::opers_analyze()
LogTraceFunction;
MultiMatchImageAnalyzer flags_analyzer(m_image);
flags_analyzer.set_task_info(m_task_data->get("BattleOpersFlag"));
flags_analyzer.set_task_data(m_task_data);
flags_analyzer.set_task_info(Task.get("BattleOpersFlag"));
if (!flags_analyzer.analyze()) {
return false;
}
flags_analyzer.sort_result();
const auto click_move = m_task_data->get("BattleOperClickRange")->rect_move;
const auto role_move = m_task_data->get("BattleOperRoleRange")->rect_move;
const auto cost_move = m_task_data->get("BattleOperCostRange")->rect_move;
const auto avlb_move = m_task_data->get("BattleOperAvailable")->rect_move;
const auto click_move = Task.get("BattleOperClickRange")->rect_move;
const auto role_move = Task.get("BattleOperRoleRange")->rect_move;
const auto cost_move = Task.get("BattleOperCostRange")->rect_move;
const auto avlb_move = Task.get("BattleOperAvailable")->rect_move;
for (const MatchRect& flag_mrect : flags_analyzer.get_result()) {
Oper oper;
@@ -105,12 +100,11 @@ asst::BattleImageAnalyzer::Role asst::BattleImageAnalyzer::oper_role_analyze(con
};
MatchImageAnalyzer role_analyzer(m_image);
role_analyzer.set_task_data(m_task_data);
Role result = Role::Unknown;
double max_score = 0;
for (auto&& [role, role_name] : RolesName) {
role_analyzer.set_task_info(m_task_data->get("BattleOperRole" + role_name));
role_analyzer.set_task_info(Task.get("BattleOperRole" + role_name));
role_analyzer.set_roi(roi);
if (!role_analyzer.analyze()) {
continue;
@@ -148,22 +142,21 @@ int asst::BattleImageAnalyzer::oper_cost_analyze(const Rect& roi)
static HashImageAnalyzer hash_analyzer;
if (!inited) {
auto [h_l, h_u] = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleOperCostChannelH"))->mask_range;
Task.get("BattleOperCostChannelH"))->mask_range;
auto [s_l, s_u] = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleOperCostChannelS"))->mask_range;
Task.get("BattleOperCostChannelS"))->mask_range;
auto [v_l, v_u] = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleOperCostChannelV"))->mask_range;
Task.get("BattleOperCostChannelV"))->mask_range;
range_lower = cv::Scalar(h_l, s_l, v_l);
range_upper = cv::Scalar(h_u, s_u, v_u);
std::unordered_map<std::string, std::string> num_hashs;
for (auto&& num : NumName) {
auto hashs_vec = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleOperCost" + num))->hashs;
Task.get("BattleOperCost" + num))->hashs;
for (size_t i = 0; i != hashs_vec.size(); ++i) {
num_hashs.emplace(num + "_" + std::to_string(i), hashs_vec.at(i));
}
}
hash_analyzer.set_task_data(m_task_data);
hash_analyzer.set_hash_templates(std::move(num_hashs));
hash_analyzer.set_need_bound(true);
hash_analyzer.set_need_split(true);
@@ -202,7 +195,7 @@ bool asst::BattleImageAnalyzer::oper_available_analyze(const Rect& roi)
Log.trace("oper available, mean", avg[2]);
static int thres = static_cast<int>(std::dynamic_pointer_cast<MatchTaskInfo>(
m_task_data->get("BattleOperAvailable"))->special_threshold);
Task.get("BattleOperAvailable"))->special_threshold);
if (avg[2] < thres) {
return false;
}
@@ -253,11 +246,10 @@ bool asst::BattleImageAnalyzer::home_analyze()
bool asst::BattleImageAnalyzer::skill_analyze()
{
const auto skill_task_ptr = m_task_data->get("BattleSkillReady");
const auto skill_task_ptr = Task.get("BattleSkillReady");
const Rect& rect_move = skill_task_ptr->rect_move;
MultiMatchImageAnalyzer mm_analyzer(m_image);
mm_analyzer.set_task_data(m_task_data);
mm_analyzer.set_task_info(skill_task_ptr);
if (!mm_analyzer.analyze()) {
return false;
@@ -271,13 +263,12 @@ bool asst::BattleImageAnalyzer::skill_analyze()
bool asst::BattleImageAnalyzer::hp_analyze()
{
// 识别 HP 的那个蓝白色图标
auto flag_task_ptr = m_task_data->get("BattleHpFlag");
auto flag_task_ptr = Task.get("BattleHpFlag");
MatchImageAnalyzer flag_analyzer(m_image);
flag_analyzer.set_task_data(m_task_data);
flag_analyzer.set_task_info(flag_task_ptr);
if (!flag_analyzer.analyze()) {
// 漏怪的时候，那个图标会变成红色的，所以多识别一次
flag_task_ptr = m_task_data->get("BattleHpFlag2");
flag_task_ptr = Task.get("BattleHpFlag2");
flag_analyzer.set_task_info(flag_task_ptr);
if (!flag_analyzer.analyze()) {
return false;
@@ -294,22 +285,21 @@ bool asst::BattleImageAnalyzer::hp_analyze()
static HashImageAnalyzer hash_analyzer;
if (!inited) {
auto [h_l, h_u] = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleHpChannelH"))->mask_range;
Task.get("BattleHpChannelH"))->mask_range;
auto [s_l, s_u] = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleHpChannelS"))->mask_range;
Task.get("BattleHpChannelS"))->mask_range;
auto [v_l, v_u] = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleHpChannelV"))->mask_range;
Task.get("BattleHpChannelV"))->mask_range;
range_lower = cv::Scalar(h_l, s_l, v_l);
range_upper = cv::Scalar(h_u, s_u, v_u);
std::unordered_map<std::string, std::string> num_hashs;
for (auto&& num : NumName) {
const auto& hashs_vec = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("BattleHp" + num))->hashs;
Task.get("BattleHp" + num))->hashs;
for (size_t i = 0; i != hashs_vec.size(); ++i) {
num_hashs.emplace(num + "_" + std::to_string(i), hashs_vec.at(i));
}
}
hash_analyzer.set_task_data(m_task_data);
hash_analyzer.set_hash_templates(std::move(num_hashs));
hash_analyzer.set_need_bound(true);
hash_analyzer.set_need_split(true);

2
src/MeoAssistant/BattleImageAnalyzer.h
View File

@@ -27,7 +27,7 @@ namespace asst
Rect rect;
};
public:
BattleImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
using AbstractImageAnalyzer::AbstractImageAnalyzer;
virtual ~BattleImageAnalyzer() = default;
virtual bool analyze() override;

13
src/MeoAssistant/CreditShopImageAnalyzer.cpp
View File

@@ -7,10 +7,6 @@
#include "AsstUtils.hpp"
asst::CreditShopImageAnalyzer::CreditShopImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
: AbstractImageAnalyzer(image, task_data)
{}
void asst::CreditShopImageAnalyzer::set_black_list(std::vector<std::string> black_list)
{
m_shopping_list = std::move(black_list);
@@ -35,10 +31,9 @@ bool asst::CreditShopImageAnalyzer::analyze()
bool asst::CreditShopImageAnalyzer::commoditys_analyze()
{
// 识别信用点的图标
const auto commodity_task_ptr = m_task_data->get("CreditShop-Commoditys");
const auto commodity_task_ptr = Task.get("CreditShop-Commoditys");
MultiMatchImageAnalyzer mm_annlyzer(m_image);
mm_annlyzer.set_task_info(commodity_task_ptr);
mm_annlyzer.set_task_data(m_task_data);
if (!mm_annlyzer.analyze()) {
return false;
@@ -65,7 +60,7 @@ bool asst::CreditShopImageAnalyzer::commoditys_analyze()
bool asst::CreditShopImageAnalyzer::whether_to_buy_analyze()
{
const auto not_to_buy_task_ptr = std::dynamic_pointer_cast<OcrTaskInfo>(
m_task_data->get("CreditShop-NotToBuy"));
Task.get("CreditShop-NotToBuy"));
for (const Rect& commodity : m_commoditys) {
// 商品名的区域
@@ -74,7 +69,6 @@ bool asst::CreditShopImageAnalyzer::whether_to_buy_analyze()
name_roi.y += commodity.y;
OcrImageAnalyzer ocr_analyzer(m_image, name_roi);
ocr_analyzer.set_task_data(m_task_data);
ocr_analyzer.set_required(m_shopping_list);
if (ocr_analyzer.analyze()) {
// 黑名单模式，有识别结果说明这个商品不买，直接跳过
@@ -99,8 +93,7 @@ bool asst::CreditShopImageAnalyzer::sold_out_analyze()
{
// 识别是否售罄
MatchImageAnalyzer sold_out_analyzer(m_image);
sold_out_analyzer.set_task_info(m_task_data->get("CreditShop-SoldOut"));
sold_out_analyzer.set_task_data(m_task_data);
sold_out_analyzer.set_task_info(Task.get("CreditShop-SoldOut"));
for (const Rect& commodity : m_need_to_buy) {
sold_out_analyzer.set_roi(commodity);

2
src/MeoAssistant/CreditShopImageAnalyzer.h
View File

@@ -6,7 +6,7 @@ namespace asst
class CreditShopImageAnalyzer final : public AbstractImageAnalyzer
{
public:
CreditShopImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
using AbstractImageAnalyzer::AbstractImageAnalyzer;
virtual ~CreditShopImageAnalyzer() = default;
virtual bool analyze() override;

11
src/MeoAssistant/CreditShoppingTask.cpp
View File

@@ -27,8 +27,7 @@ bool asst::CreditShoppingTask::_run()
{
const cv::Mat image = m_ctrler->get_image();
CreditShopImageAnalyzer shop_analyzer(image, m_task_data);
shop_analyzer.set_task_data(m_task_data);
CreditShopImageAnalyzer shop_analyzer(image);
if (!shop_analyzer.analyze()) {
return false;
}
@@ -48,11 +47,11 @@ bool asst::CreditShoppingTask::_run()
// “购买商品”按钮
static Rect buy_it_rect;
if (buy_it_rect.empty()) {
const auto buy_it_task_ptr = m_task_data->get("CreditShop-BuyIt");
const auto buy_it_task_ptr = Task.get("CreditShop-BuyIt");
const cv::Mat buy_image = m_ctrler->get_image();
MatchImageAnalyzer buy_it_analyzer(buy_image);
buy_it_analyzer.set_task_data(m_task_data);
buy_it_analyzer.set_task_info(buy_it_task_ptr);
if (!buy_it_analyzer.analyze()) {
// 没识别到“购买商品”按钮，不应该出现这种情况，TODO 报错
@@ -73,8 +72,8 @@ bool asst::CreditShoppingTask::_run()
const cv::Mat prompt_image = m_ctrler->get_image();
OcrImageAnalyzer prompt_analyzer(prompt_image);
prompt_analyzer.set_task_data(m_task_data);
prompt_analyzer.set_task_info(m_task_data->get("CreditShop-NoMoney"));
prompt_analyzer.set_task_info(Task.get("CreditShop-NoMoney"));
if (prompt_analyzer.analyze()) {
click_return_button();
return true;

38
src/MeoAssistant/InfrastAbstractTask.cpp
View File

@@ -78,7 +78,7 @@ bool asst::InfrastAbstractTask::enter_facility(int index)
InfrastFacilityImageAnalyzer analyzer(image);
analyzer.set_to_be_analyzed({ facility_name() });
analyzer.set_task_data(m_task_data);
if (!analyzer.analyze()) {
Log.trace("result is empty");
return false;
@@ -94,7 +94,7 @@ bool asst::InfrastAbstractTask::enter_facility(int index)
m_ctrler->click(rect);
const auto enter_task_ptr = m_task_data->get("InfrastEnterFacility");
const auto enter_task_ptr = Task.get("InfrastEnterFacility");
sleep(enter_task_ptr->rear_delay);
return true;
@@ -111,9 +111,9 @@ bool asst::InfrastAbstractTask::enter_oper_list_page()
void asst::InfrastAbstractTask::async_swipe_of_operlist(bool reverse)
{
LogTraceFunction;
static Rect begin_rect = m_task_data->get("InfrastOperListSwipeBegin")->specific_rect;
static Rect end_rect = m_task_data->get("InfrastOperListSwipeEnd")->specific_rect;
static int duration = m_task_data->get("InfrastOperListSwipeBegin")->pre_delay;
static Rect begin_rect = Task.get("InfrastOperListSwipeBegin")->specific_rect;
static Rect end_rect = Task.get("InfrastOperListSwipeEnd")->specific_rect;
static int duration = Task.get("InfrastOperListSwipeBegin")->pre_delay;
if (!reverse) {
m_last_swipe_id = m_ctrler->swipe(begin_rect, end_rect, duration, false, 0, true);
@@ -126,7 +126,7 @@ void asst::InfrastAbstractTask::async_swipe_of_operlist(bool reverse)
void asst::InfrastAbstractTask::await_swipe()
{
LogTraceFunction;
static int extra_delay = m_task_data->get("InfrastOperListSwipeBegin")->rear_delay;
static int extra_delay = Task.get("InfrastOperListSwipeBegin")->rear_delay;
m_ctrler->wait(m_last_swipe_id);
sleep(extra_delay);
@@ -165,11 +165,11 @@ void asst::InfrastAbstractTask::swipe_of_operlist(bool reverse)
void asst::InfrastAbstractTask::swipe_to_the_left_of_operlist(int loop_times)
{
LogTraceFunction;
static Rect begin_rect = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
static Rect end_rect = m_task_data->get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
static int duration = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
static int extra_delay = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
static int cfg_loop_times = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->max_times;
static Rect begin_rect = Task.get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
static Rect end_rect = Task.get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
static int duration = Task.get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
static int extra_delay = Task.get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
static int cfg_loop_times = Task.get("InfrastOperListSwipeToTheLeftBegin")->max_times;
for (int i = 0; i != cfg_loop_times * loop_times; ++i) {
if (need_exit()) {
@@ -183,10 +183,10 @@ void asst::InfrastAbstractTask::swipe_to_the_left_of_operlist(int loop_times)
void asst::InfrastAbstractTask::swipe_to_the_left_of_main_ui()
{
LogTraceFunction;
static Rect begin_rect = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
static Rect end_rect = m_task_data->get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
static int duration = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
static int extra_delay = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
static Rect begin_rect = Task.get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
static Rect end_rect = Task.get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
static int duration = Task.get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
static int extra_delay = Task.get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
m_ctrler->swipe(end_rect, begin_rect, duration, true, extra_delay, false);
}
@@ -194,10 +194,10 @@ void asst::InfrastAbstractTask::swipe_to_the_left_of_main_ui()
void asst::InfrastAbstractTask::swipe_to_the_right_of_main_ui()
{
LogTraceFunction;
static Rect begin_rect = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
static Rect end_rect = m_task_data->get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
static int duration = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
static int extra_delay = m_task_data->get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
static Rect begin_rect = Task.get("InfrastOperListSwipeToTheLeftBegin")->specific_rect;
static Rect end_rect = Task.get("InfrastOperListSwipeToTheLeftEnd")->specific_rect;
static int duration = Task.get("InfrastOperListSwipeToTheLeftBegin")->pre_delay;
static int extra_delay = Task.get("InfrastOperListSwipeToTheLeftBegin")->rear_delay;
m_ctrler->swipe(begin_rect, end_rect, duration, true, extra_delay, false);
}

4
src/MeoAssistant/InfrastClueImageAnalyzer.cpp
View File

@@ -16,8 +16,8 @@ bool asst::InfrastClueImageAnalyzer::analyze()
bool asst::InfrastClueImageAnalyzer::clue_detect()
{
MultiMatchImageAnalyzer clue_analyzer(m_image);
clue_analyzer.set_task_info(m_task_data->get("InfrastClue"));
clue_analyzer.set_task_data(m_task_data);
clue_analyzer.set_task_info(Task.get("InfrastClue"));
clue_analyzer.set_roi(m_roi); // 该任务以外部设置的roi为准
if (!clue_analyzer.analyze()) {
return false;

4
src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
View File

@@ -10,9 +10,9 @@ bool asst::InfrastClueVacancyImageAnalyzer::analyze()
const static std::string clue_vacancy = "InfrastClueVacancy";
MatchImageAnalyzer analyzer(m_image);
analyzer.set_task_data(m_task_data);
for (const std::string& suffix : m_to_be_analyzed) {
analyzer.set_task_info(m_task_data->get(clue_vacancy + suffix));
analyzer.set_task_info(Task.get(clue_vacancy + suffix));
if (!analyzer.analyze()) {
Log.trace("no", clue_vacancy, suffix);
continue;

2
src/MeoAssistant/InfrastDormTask.cpp
View File

@@ -44,7 +44,7 @@ bool asst::InfrastDormTask::opers_choose()
}
const auto image = m_ctrler->get_image();
InfrastOperImageAnalyzer oper_analyzer(image);
oper_analyzer.set_task_data(m_task_data);
const int without_skill = InfrastOperImageAnalyzer::All ^ InfrastOperImageAnalyzer::Skill;
oper_analyzer.set_to_be_calced(without_skill);
if (!oper_analyzer.analyze()) {

4
src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
View File

@@ -22,10 +22,10 @@ bool asst::InfrastFacilityImageAnalyzer::analyze()
const static std::vector<std::string> task_name_suffix = { "", "Mini" };
MultiMatchImageAnalyzer mm_analyzer(m_image);
mm_analyzer.set_task_data(m_task_data);
auto task_analyze = [&](const std::string& task_name) -> bool {
mm_analyzer.set_task_info(m_task_data->get(task_name));
mm_analyzer.set_task_info(Task.get(task_name));
return mm_analyzer.analyze();
};

2
src/MeoAssistant/InfrastInfoTask.cpp
View File

@@ -12,7 +12,7 @@ bool asst::InfrastInfoTask::_run()
const auto image = m_ctrler->get_image();
InfrastFacilityImageAnalyzer analyzer(image);
analyzer.set_task_data(m_task_data);
analyzer.set_to_be_analyzed({ "Mfg", "Trade", "Power", "Dorm" });
if (!analyzer.analyze()) {
return false;

32
src/MeoAssistant/InfrastOperImageAnalyzer.cpp
View File

@@ -81,17 +81,17 @@ void asst::InfrastOperImageAnalyzer::oper_detect()
{
LogTraceFunction;
const Rect upper_roi = m_task_data->get("InfrastSkillsUpper")->roi;
const Rect lower_roi = m_task_data->get("InfrastSkillsLower")->roi;
const Rect upper_roi = Task.get("InfrastSkillsUpper")->roi;
const Rect lower_roi = Task.get("InfrastSkillsLower")->roi;
const std::vector<Rect> all_roi = { upper_roi, lower_roi };
const Rect skill_rect_move = m_task_data->get("InfrastSkills")->rect_move;
const Rect hash_rect_move = m_task_data->get("InfrastOperNameHash")->rect_move;
const Rect prg_rect_move = m_task_data->get("InfrastOperMoodProgressBar")->roi;
const Rect skill_rect_move = Task.get("InfrastSkills")->rect_move;
const Rect hash_rect_move = Task.get("InfrastOperNameHash")->rect_move;
const Rect prg_rect_move = Task.get("InfrastOperMoodProgressBar")->roi;
const std::vector<Rect> all_rect_move = { skill_rect_move, hash_rect_move, prg_rect_move };
InfrastSmileyImageAnalyzer smiley_analyzer(m_image);
smiley_analyzer.set_task_data(m_task_data);
for (auto&& roi : all_roi) {
smiley_analyzer.set_roi(roi);
@@ -132,7 +132,7 @@ void asst::InfrastOperImageAnalyzer::mood_analyze()
LogTraceFunction;
const auto prg_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
m_task_data->get("InfrastOperMoodProgressBar"));
Task.get("InfrastOperMoodProgressBar"));
uint8_t prg_lower_limit = static_cast<uint8_t>(prg_task_ptr->templ_threshold);
int prg_diff_thres = static_cast<int>(prg_task_ptr->special_threshold);
Rect rect_move = prg_task_ptr->rect_move;
@@ -208,10 +208,10 @@ void asst::InfrastOperImageAnalyzer::face_hash_analyze()
{
LogTraceFunction;
const Rect hash_rect_move = m_task_data->get("InfrastOperFaceHash")->rect_move;
const Rect hash_rect_move = Task.get("InfrastOperFaceHash")->rect_move;
HashImageAnalyzer hash_analyzer(m_image);
hash_analyzer.set_task_data(m_task_data);
for (auto&& oper : m_result) {
Rect roi = oper.smiley.rect.move(hash_rect_move);
hash_analyzer.set_roi(roi);
@@ -225,10 +225,10 @@ void asst::InfrastOperImageAnalyzer::name_hash_analyze()
LogTraceFunction;
const auto task_ptr = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("InfrastOperNameHash"));
Task.get("InfrastOperNameHash"));
HashImageAnalyzer hash_analyzer(m_image);
hash_analyzer.set_task_data(m_task_data);
hash_analyzer.set_mask_range(task_ptr->mask_range);
hash_analyzer.set_need_bound(true);
for (auto&& oper : m_result) {
@@ -244,11 +244,11 @@ void asst::InfrastOperImageAnalyzer::skill_analyze()
LogTraceFunction;
const auto task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
m_task_data->get("InfrastSkills"));
Task.get("InfrastSkills"));
const auto bright_thres = task_ptr->special_threshold;
MatchImageAnalyzer skill_analyzer(m_image);
skill_analyzer.set_task_data(m_task_data);
skill_analyzer.set_mask_range(task_ptr->mask_range);
skill_analyzer.set_threshold(task_ptr->templ_threshold);
@@ -370,7 +370,7 @@ void asst::InfrastOperImageAnalyzer::selected_analyze()
LogTraceFunction;
const auto selected_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
m_task_data->get("InfrastOperSelected"));
Task.get("InfrastOperSelected"));
Rect rect_move = selected_task_ptr->rect_move;
for (auto&& oper : m_result) {
@@ -406,11 +406,11 @@ void asst::InfrastOperImageAnalyzer::doing_analyze()
{
LogTraceFunction;
const auto working_task_ptr = m_task_data->get("InfrastOperOnShift");
const auto working_task_ptr = Task.get("InfrastOperOnShift");
Rect rect_move = working_task_ptr->rect_move;
MatchImageAnalyzer working_analyzer(m_image);
working_analyzer.set_task_data(m_task_data);
working_analyzer.set_task_info(working_task_ptr);
for (auto&& oper : m_result) {

30
src/MeoAssistant/InfrastProductionTask.cpp
View File

@@ -40,14 +40,14 @@ bool asst::InfrastProductionTask::shift_facility_list()
if (!facility_list_detect() || need_exit()) {
return false;
}
const auto tab_task_ptr = m_task_data->get("InfrastFacilityListTab" + facility_name());
const auto tab_task_ptr = Task.get("InfrastFacilityListTab" + facility_name());
MatchImageAnalyzer add_analyzer;
add_analyzer.set_task_data(m_task_data);
const auto add_task_ptr = m_task_data->get("InfrastAddOperator" + facility_name() + m_work_mode_name);
const auto add_task_ptr = Task.get("InfrastAddOperator" + facility_name() + m_work_mode_name);
add_analyzer.set_task_info(add_task_ptr);
MultiMatchImageAnalyzer locked_analyzer;
locked_analyzer.set_task_data(m_task_data);
locked_analyzer.set_task_info(m_task_data->get("InfrastOperLocked" + facility_name()));
locked_analyzer.set_task_info(Task.get("InfrastOperLocked" + facility_name()));
for (; m_cur_facility_index < m_facility_list_tabs.size(); ++m_cur_facility_index) {
Rect tab = m_facility_list_tabs.at(m_cur_facility_index);
@@ -80,12 +80,12 @@ bool asst::InfrastProductionTask::shift_facility_list()
/* 识别当前正在造什么 */
MatchImageAnalyzer product_analyzer(image);
product_analyzer.set_task_data(m_task_data);
auto& all_products = Resrc.infrast().get_facility_info(facility_name()).products;
std::string cur_product = all_products.at(0);
double max_score = 0;
for (const std::string& product : all_products) {
product_analyzer.set_task_info(m_task_data->get("InfrastFlag" + product));
product_analyzer.set_task_info(Task.get("InfrastFlag" + product));
if (product_analyzer.analyze()) {
double score = product_analyzer.get_result().score;
if (score > max_score) {
@@ -182,7 +182,7 @@ size_t asst::InfrastProductionTask::opers_detect()
const auto image = m_ctrler->get_image();
InfrastOperImageAnalyzer oper_analyzer(image);
oper_analyzer.set_task_data(m_task_data);
oper_analyzer.set_facility(facility_name());
if (!oper_analyzer.analyze()) {
@@ -192,7 +192,7 @@ size_t asst::InfrastProductionTask::opers_detect()
max_num_of_opers_per_page = (std::max)(max_num_of_opers_per_page, cur_all_opers.size());
const int face_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("InfrastOperFaceHash"))->dist_threshold;
Task.get("InfrastOperFaceHash"))->dist_threshold;
int cur_available_num = static_cast<int>(cur_all_opers.size());
for (const auto& cur_oper : cur_all_opers) {
if (cur_oper.skills.empty()) {
@@ -296,7 +296,7 @@ bool asst::InfrastProductionTask::optimal_calc()
}
const int name_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("InfrastOperNameHash"))->dist_threshold;
Task.get("InfrastOperNameHash"))->dist_threshold;
// 遍历所有组合，找到效率最高的
auto& all_group = Resrc.infrast().get_skills_group(facility_name());
@@ -456,9 +456,9 @@ bool asst::InfrastProductionTask::opers_choose()
int cur_max_num_of_opers = facility_info.max_num_of_opers - m_cur_num_of_lokced_opers;
const int name_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("InfrastOperNameHash"))->dist_threshold;
Task.get("InfrastOperNameHash"))->dist_threshold;
const int face_hash_thres = std::dynamic_pointer_cast<HashTaskInfo>(
m_task_data->get("InfrastOperFaceHash"))->dist_threshold;
Task.get("InfrastOperFaceHash"))->dist_threshold;
while (true) {
if (need_exit()) {
return false;
@@ -466,7 +466,7 @@ bool asst::InfrastProductionTask::opers_choose()
const auto image = m_ctrler->get_image();
InfrastOperImageAnalyzer oper_analyzer(image);
oper_analyzer.set_task_data(m_task_data);
oper_analyzer.set_facility(facility_name());
if (!oper_analyzer.analyze()) {
@@ -624,8 +624,8 @@ bool asst::InfrastProductionTask::facility_list_detect()
const auto image = m_ctrler->get_image();
MultiMatchImageAnalyzer mm_analyzer(image);
mm_analyzer.set_task_data(m_task_data);
mm_analyzer.set_task_info(m_task_data->get("InfrastFacilityListTab" + facility_name()));
mm_analyzer.set_task_info(Task.get("InfrastFacilityListTab" + facility_name()));
if (!mm_analyzer.analyze()) {
return false;

12
src/MeoAssistant/InfrastReceptionTask.cpp
View File

@@ -65,7 +65,7 @@ bool asst::InfrastReceptionTask::use_clue()
// 所有的空位分析一次，看看还缺哪些线索
InfrastClueVacancyImageAnalyzer vacancy_analyzer(image);
vacancy_analyzer.set_task_data(m_task_data);
vacancy_analyzer.set_to_be_analyzed(clue_suffix);
if (!vacancy_analyzer.analyze()) {
}
@@ -102,7 +102,7 @@ bool asst::InfrastReceptionTask::proc_clue_vacancy()
}
// 先识别线索的空位
InfrastClueVacancyImageAnalyzer vacancy_analyzer(image);
vacancy_analyzer.set_task_data(m_task_data);
vacancy_analyzer.set_to_be_analyzed({ clue });
if (!vacancy_analyzer.analyze()) {
continue;
@@ -110,14 +110,14 @@ bool asst::InfrastReceptionTask::proc_clue_vacancy()
// 点开线索的空位
Rect vacancy = vacancy_analyzer.get_vacancy().cbegin()->second;
m_ctrler->click(vacancy);
int delay = m_task_data->get(clue_vacancy + clue)->rear_delay;
int delay = Task.get(clue_vacancy + clue)->rear_delay;
sleep(delay);
// 识别右边列表中的线索，然后用最底下的那个（一般都是剩余时间最短的）
//swipe_to_the_bottom_of_clue_list_on_the_right();
image = m_ctrler->get_image();
InfrastClueImageAnalyzer clue_analyzer(image);
clue_analyzer.set_task_data(m_task_data);
if (!clue_analyzer.analyze()) {
continue;
}
@@ -145,9 +145,9 @@ bool asst::InfrastReceptionTask::shift()
LogTraceFunction;
const auto image = m_ctrler->get_image();
MatchImageAnalyzer add_analyzer(image);
add_analyzer.set_task_data(m_task_data);
const auto raw_task_ptr = m_task_data->get("InfrastAddOperator" + facility_name() + m_work_mode_name);
const auto raw_task_ptr = Task.get("InfrastAddOperator" + facility_name() + m_work_mode_name);
switch (raw_task_ptr->algorithm) {
case AlgorithmType::JustReturn:
if (raw_task_ptr->action == ProcessTaskAction::ClickRect) {

4
src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
View File

@@ -15,11 +15,11 @@ bool asst::InfrastSmileyImageAnalyzer::analyze()
m_result.clear();
MultiMatchImageAnalyzer mm_analyzer(m_image);
mm_analyzer.set_task_data(m_task_data);
decltype(m_result) temp_result;
for (const auto& [type, task_name] : smiley_map) {
mm_analyzer.set_task_info(m_task_data->get(task_name));
mm_analyzer.set_task_info(Task.get(task_name));
mm_analyzer.set_roi(m_roi);
if (!mm_analyzer.analyze()) {
continue;

4
src/MeoAssistant/MeoAssistant.vcxproj.filters
View File

@@ -283,7 +283,7 @@
<Filter>头文件\Task</Filter>
</ClInclude>
<ClInclude Include="MallTask.h">
<Filter>头文件</Filter>
<Filter>头文件\Task</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
@@ -462,7 +462,7 @@
<Filter>源文件\Task</Filter>
</ClCompile>
<ClCompile Include="MallTask.cpp">
<Filter>源文件</Filter>
<Filter>源文件\Task</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>

12
src/MeoAssistant/PackageTask.cpp
View File

@@ -18,8 +18,7 @@ bool asst::PackageTask::run()
task_ptr->set_exit_flag(m_exit_flag)
.set_ctrler(m_ctrler)
.set_status(m_status)
.set_task_data(m_task_data);
.set_status(m_status);
if (!task_ptr->run()) {
return false;
@@ -65,12 +64,3 @@ asst::AbstractTask& asst::PackageTask::set_status(std::shared_ptr<RuntimeStatus>
}
return *this;
}
asst::AbstractTask& asst::PackageTask::set_task_data(std::shared_ptr<TaskData> task_data) noexcept
{
AbstractTask::set_task_data(task_data);
for (auto&& sub : m_subtasks) {
sub->set_task_data(task_data);
}
return *this;
}

1
src/MeoAssistant/PackageTask.h
View File

@@ -26,7 +26,6 @@ namespace asst
virtual AbstractTask& set_retry_times(int times) noexcept;
virtual AbstractTask& set_ctrler(std::shared_ptr<Controller> ctrler) noexcept;
virtual AbstractTask& set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
virtual AbstractTask& set_task_data(std::shared_ptr<TaskData> task_data) noexcept;
protected:
virtual bool _run() override { return true; }

6
src/MeoAssistant/ProcessTask.cpp
View File

@@ -88,16 +88,16 @@ bool ProcessTask::_run()
std::shared_ptr<TaskInfo> cur_task_ptr = nullptr;
// 如果第一个任务是JustReturn的，那就没必要再截图并计算了
if (auto front_task_ptr = m_task_data->get(m_cur_tasks_name.front());
if (auto front_task_ptr = Task.get(m_cur_tasks_name.front());
front_task_ptr->algorithm == AlgorithmType::JustReturn) {
cur_task_ptr = front_task_ptr;
}
else {
const auto image = m_ctrler->get_image();
ProcessTaskImageAnalyzer analyzer(image, m_cur_tasks_name);
analyzer.set_task_data(m_task_data);
analyzer.set_status(m_status);
analyzer.set_task_data(m_task_data);
if (!analyzer.analyze()) {
return false;
}

2
src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
View File

@@ -108,7 +108,7 @@ bool asst::ProcessTaskImageAnalyzer::analyze()
m_result_rect = Rect();
for (const std::string& task_name : m_tasks_name) {
auto task_ptr = m_task_data->get(task_name);
auto task_ptr = Task.get(task_name);
switch (task_ptr->algorithm) {
case AlgorithmType::JustReturn:

16
src/MeoAssistant/RecruitImageAnalyzer.cpp
View File

@@ -23,7 +23,7 @@ bool asst::RecruitImageAnalyzer::tags_analyze()
static OcrImageAnalyzer tags_analyzer;
if (!analyzer_inited) {
const auto tags_task_ptr = std::dynamic_pointer_cast<OcrTaskInfo>(
m_task_data->get("RecruitTags"));
Task.get("RecruitTags"));
tags_analyzer.set_roi(tags_task_ptr->roi);
auto& all_tags_set = Resrc.recruit().get_all_tags();
std::vector<std::string> all_tags_vec;
@@ -33,7 +33,7 @@ bool asst::RecruitImageAnalyzer::tags_analyze()
if (ssr_iter != all_tags_vec.end()) {
std::swap(*ssr_iter, all_tags_vec.front());
}
tags_analyzer.set_task_data(m_task_data);
tags_analyzer.set_required(std::move(all_tags_vec));
tags_analyzer.set_replace(tags_task_ptr->replace_map);
analyzer_inited = true;
@@ -53,11 +53,11 @@ bool asst::RecruitImageAnalyzer::tags_analyze()
bool asst::RecruitImageAnalyzer::time_analyze()
{
const auto time_task_ptr = m_task_data->get("RecruitTime");
const auto time_task_ptr = Task.get("RecruitTime");
MatchImageAnalyzer time_analyzer(m_image);
time_analyzer.set_task_info(time_task_ptr);
time_analyzer.set_task_data(m_task_data);
if (time_analyzer.analyze()) {
Rect rect = time_analyzer.get_result().rect;
@@ -77,8 +77,8 @@ bool asst::RecruitImageAnalyzer::time_analyze()
bool asst::RecruitImageAnalyzer::confirm_analyze()
{
MatchImageAnalyzer confirm_analyzer(m_image);
confirm_analyzer.set_task_info(m_task_data->get("RecruitConfirm"));
confirm_analyzer.set_task_data(m_task_data);
confirm_analyzer.set_task_info(Task.get("RecruitConfirm"));
if (confirm_analyzer.analyze()) {
m_confirm_rect = confirm_analyzer.get_result().rect;
@@ -91,8 +91,8 @@ bool asst::RecruitImageAnalyzer::confirm_analyze()
bool asst::RecruitImageAnalyzer::refresh_analyze()
{
MatchImageAnalyzer refresh_analyzer(m_image);
refresh_analyzer.set_task_data(m_task_data);
refresh_analyzer.set_task_info(m_task_data->get("RecruitRefresh"));
refresh_analyzer.set_task_info(Task.get("RecruitRefresh"));
if (refresh_analyzer.analyze()) {
m_refresh_rect = refresh_analyzer.get_result().rect;

2
src/MeoAssistant/RecruitTask.cpp
View File

@@ -18,7 +18,7 @@ bool RecruitTask::_run()
const cv::Mat image = m_ctrler->get_image();
RecruitImageAnalyzer analyzer(image);
analyzer.set_task_data(m_task_data);
if (!analyzer.analyze()) {
return false;

6
src/MeoAssistant/Resource.cpp
View File

@@ -28,8 +28,8 @@ bool asst::Resource::load(const std::string& dir)
m_last_error = std::string(GeneralCfgFilename) + ": " + m_general_cfg_unique_ins.get_last_error();
return false;
}
if (!StaticTaskData::get_instance().load(dir + TaskDataFilename)) {
m_last_error = std::string(TaskDataFilename) + ": " + StaticTaskData::get_instance().get_last_error();
if (!TaskData::get_instance().load(dir + TaskDataFilename)) {
m_last_error = std::string(TaskDataFilename) + ": " + TaskData::get_instance().get_last_error();
return false;
}
@@ -50,7 +50,7 @@ bool asst::Resource::load(const std::string& dir)
/* 加载模板图片资源 */
// task所需要的模板资源
m_templ_resource_unique_ins.append_load_required(StaticTaskData::get_instance().get_templ_required());
m_templ_resource_unique_ins.append_load_required(TaskData::get_instance().get_templ_required());
// 基建所需要的模板资源
m_templ_resource_unique_ins.append_load_required(m_infrast_cfg_unique_ins.get_templ_required());

14
src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
View File

@@ -59,14 +59,14 @@ bool asst::RoguelikeBattleTaskPlugin::get_stage_info()
bool calced = false;
if (m_stage_name.empty()) {
const auto stage_name_task_ptr = m_task_data->get("BattleStageName");
const auto stage_name_task_ptr = Task.get("BattleStageName");
sleep(stage_name_task_ptr->pre_delay);
constexpr int StageNameRetryTimes = 50;
for (int i = 0; i != StageNameRetryTimes; ++i) {
cv::Mat image = m_ctrler->get_image();
OcrImageAnalyzer name_analyzer(image);
name_analyzer.set_task_data(m_task_data);
name_analyzer.set_task_info(stage_name_task_ptr);
if (!name_analyzer.analyze()) {
continue;
@@ -134,8 +134,8 @@ bool asst::RoguelikeBattleTaskPlugin::auto_battle()
using Oper = asst::BattleImageAnalyzer::Oper;
BattleImageAnalyzer battle_analyzer(m_ctrler->get_image(), m_task_data);
battle_analyzer.set_task_data(m_task_data);
BattleImageAnalyzer battle_analyzer(m_ctrler->get_image());
if (!battle_analyzer.analyze()) {
return false;
}
@@ -173,8 +173,8 @@ bool asst::RoguelikeBattleTaskPlugin::auto_battle()
Role::Tank,
Role::Drone
};
const auto use_oper_task_ptr = m_task_data->get("BattleUseOper");
const auto swipe_oper_task_ptr = m_task_data->get("BattleSwipeOper");
const auto use_oper_task_ptr = Task.get("BattleUseOper");
const auto swipe_oper_task_ptr = Task.get("BattleSwipeOper");
// 点击当前最合适的干员
Oper opt_oper;
@@ -295,7 +295,7 @@ void asst::RoguelikeBattleTaskPlugin::clear()
//asst::Rect asst::RoguelikeBattleTaskPlugin::get_placed_by_cv()
//{
// BattlePerspectiveImageAnalyzer placed_analyzer(m_ctrler->get_image());
// placed_analyzer.set_task_data(m_task_data);
// placed_analyzer.set_src_homes(m_home_cache);
// if (!placed_analyzer.analyze()) {
// return Rect();

10
src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
View File

@@ -5,15 +5,11 @@
#include "TaskData.h"
#include "Logger.hpp"
asst::RoguelikeFormationImageAnalyzer::RoguelikeFormationImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data)
: AbstractImageAnalyzer(image, task_data)
{}
bool asst::RoguelikeFormationImageAnalyzer::analyze()
{
MultiMatchImageAnalyzer opers_analyzer(m_image);
opers_analyzer.set_task_info(m_task_data->get("Roguelike1FormationOper"));
opers_analyzer.set_task_data(m_task_data);
opers_analyzer.set_task_info(Task.get("Roguelike1FormationOper"));
if (!opers_analyzer.analyze()) {
return false;
}
@@ -51,7 +47,7 @@ bool asst::RoguelikeFormationImageAnalyzer::selected_analyze(const Rect& roi)
cv::Mat hsv;
const auto selected_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(
m_task_data->get("Roguelike1FormationOperSelected"));
Task.get("Roguelike1FormationOperSelected"));
cv::cvtColor(img_roi, hsv, cv::COLOR_BGR2HSV);
std::vector<cv::Mat> channels;
cv::split(hsv, channels);

2
src/MeoAssistant/RoguelikeFormationImageAnalyzer.h
View File

@@ -13,7 +13,7 @@ namespace asst
// TODO
};
public:
RoguelikeFormationImageAnalyzer(const cv::Mat image, std::shared_ptr<TaskData> task_data);
using AbstractImageAnalyzer::AbstractImageAnalyzer;
virtual ~RoguelikeFormationImageAnalyzer() = default;
virtual bool analyze() override;

4
src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
View File

@@ -22,8 +22,8 @@ bool asst::RoguelikeFormationTaskPlugin::verify(AsstMsg msg, const json::value&
bool asst::RoguelikeFormationTaskPlugin::_run()
{
RoguelikeFormationImageAnalyzer formation_analyzer(m_ctrler->get_image(), m_task_data);
formation_analyzer.set_task_data(m_task_data);
RoguelikeFormationImageAnalyzer formation_analyzer(m_ctrler->get_image());
if (!formation_analyzer.analyze()) {
return false;
}

4
src/MeoAssistant/StageDropsTaskPlugin.cpp
View File

@@ -72,7 +72,7 @@ bool asst::StageDropsTaskPlugin::recognize_drops()
{
LogTraceFunction;
sleep(m_task_data->get("PRTS")->rear_delay);
sleep(Task.get("PRTS")->rear_delay);
if (need_exit()) {
return false;
}
@@ -134,7 +134,7 @@ void asst::StageDropsTaskPlugin::set_startbutton_delay()
if (pre_start_time > 0) {
int64_t duration = time(nullptr) - pre_start_time;
int elapsed = m_task_data->get("EndOfAction")->pre_delay + m_task_data->get("PRTS")->rear_delay;
int elapsed = Task.get("EndOfAction")->pre_delay + Task.get("PRTS")->rear_delay;
int64_t delay = duration * 1000 - elapsed;
m_cast_ptr->set_rear_delay("StartButton2", static_cast<int>(delay));
}

52
src/MeoAssistant/TaskData.cpp
View File

@@ -9,7 +9,7 @@
#include "TemplResource.h"
#include "Logger.hpp"
const std::shared_ptr<asst::TaskInfo> asst::StaticTaskData::get(const std::string& name) const noexcept
const std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name) const noexcept
{
if (auto iter = m_all_tasks_info.find(name);
iter != m_all_tasks_info.cend()) {
@@ -20,17 +20,17 @@ const std::shared_ptr<asst::TaskInfo> asst::StaticTaskData::get(const std::strin
}
}
const std::unordered_set<std::string>& asst::StaticTaskData::get_templ_required() const noexcept
const std::unordered_set<std::string>& asst::TaskData::get_templ_required() const noexcept
{
return m_templ_required;
}
std::shared_ptr<asst::TaskInfo> asst::StaticTaskData::get(const std::string& name)
std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name)
{
return m_all_tasks_info[name];
}
bool asst::StaticTaskData::parse(const json::value& json)
bool asst::TaskData::parse(const json::value& json)
{
LogTraceFunction;
@@ -214,47 +214,3 @@ bool asst::StaticTaskData::parse(const json::value& json)
#endif
return true;
}
const std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name) const noexcept
{
if (auto iter = m_specal_tasks_info.find(name);
iter != m_specal_tasks_info.cend()) {
return iter->second;
}
else {
return StaticTaskData::get_instance().get(name);
}
}
std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name)
{
if (auto iter = m_specal_tasks_info.find(name);
iter != m_specal_tasks_info.cend()) {
return iter->second;
}
else {
return StaticTaskData::get_instance().get(name);
}
}
bool asst::TaskData::set_ocr_text(const std::string& key, std::vector<std::string> text)
{
if (auto iter = m_specal_tasks_info.find(key);
iter != m_specal_tasks_info.end()) {
std::dynamic_pointer_cast<OcrTaskInfo>(iter->second)->text = std::move(text);
return true;
}
else {
auto raw_task_ptr = StaticTaskData::get_instance().get(key);
if (!raw_task_ptr) {
Log.error("Task", key, "Not Exists");
return false;
}
// 拷贝一份
OcrTaskInfo info = *std::dynamic_pointer_cast<OcrTaskInfo>(raw_task_ptr);
info.text = std::move(text);
auto specail_ptr = std::make_shared<OcrTaskInfo>(std::move(info));
m_specal_tasks_info.emplace(key, specail_ptr);
return true;
}
}

29
src/MeoAssistant/TaskData.h
View File

@@ -10,17 +10,17 @@ namespace asst
{
struct TaskInfo;
class StaticTaskData : public AbstractConfiger
class TaskData : public AbstractConfiger
{
public:
StaticTaskData(const StaticTaskData&) = delete;
StaticTaskData(StaticTaskData&&) = delete;
TaskData(const TaskData&) = delete;
TaskData(TaskData&&) = delete;
virtual ~StaticTaskData() = default;
virtual ~TaskData() = default;
static StaticTaskData& get_instance()
static TaskData& get_instance()
{
static StaticTaskData unique_instance;
static TaskData unique_instance;
return unique_instance;
}
const std::unordered_set<std::string>& get_templ_required() const noexcept;
@@ -29,7 +29,7 @@ namespace asst
std::shared_ptr<TaskInfo> get(const std::string& name);
protected:
StaticTaskData() = default;
TaskData() = default;
virtual bool parse(const json::value& json);
@@ -37,18 +37,5 @@ namespace asst
std::unordered_set<std::string> m_templ_required;
};
class TaskData
{
public:
TaskData() = default;
~TaskData() noexcept = default;
const std::shared_ptr<TaskInfo> get(const std::string& name) const noexcept;
std::shared_ptr<TaskInfo> get(const std::string& name);
bool set_ocr_text(const std::string& key, std::vector<std::string> text);
private:
std::unordered_map<std::string, std::shared_ptr<TaskInfo>> m_specal_tasks_info;
};
static auto& Task = TaskData::get_instance();
}