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

refactor.重构添加任务接口

Browse Source
This commit is contained in:
MistEO
2022-03-08 23:57:37 +08:00
parent 6be8a43c1a
commit a1fb78cc32
37 changed files with 447 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files

353
src/MeoAssistant/Assistant.cpp
View File

@@ -9,26 +9,12 @@
#include "Controller.h"
#include "Logger.hpp"
#include "Resource.h"
#include "CreditShoppingTask.h"
#include "RoguelikeBattleTaskPlugin.h"
#include "RoguelikeFormationTaskPlugin.h"
#include "InfrastDormTask.h"
#include "InfrastInfoTask.h"
#include "InfrastMfgTask.h"
#include "InfrastOfficeTask.h"
#include "InfrastPowerTask.h"
#include "InfrastReceptionTask.h"
#include "InfrastTradeTask.h"
#include "ProcessTask.h"
#include "RecruitTask.h"
#include "AutoRecruitTask.h"
#include "InfrastControlTask.h"
#include "RuntimeStatus.h"
#include "StageDropsTaskPlugin.h"
#include "DronesForShamareTaskPlugin.h"
#include "AsstDef.h"
#include "FightTask.h"
#include "StartUpTask.h"
using namespace asst;
Assistant::Assistant(AsstApiCallback callback, void* callback_arg)
@@ -78,329 +64,46 @@ bool asst::Assistant::connect(const std::string& adb_path, const std::string& ad
return ret;
}
bool asst::Assistant::append_start_up()
PackageTask* asst::Assistant::append_task(const std::string& type, const std::string& params)
{
LogTraceFunction;
if (!m_inited) {
return false;
Log.info(__FUNCTION__, type, params);
auto ret = json::parse(params);
if (!ret) {
return nullptr;
}
auto task_ptr = std::make_shared<ProcessTask>(task_callback, (void*)this, "StartUp");
task_ptr->set_tasks({ "StartUp" })
.set_times_limit("ReturnToTerminal", 0)
.set_times_limit("Terminal", 0);
std::unique_lock<std::mutex> lock(m_mutex);
m_tasks_queue.emplace(task_ptr);
return true;
}
bool asst::Assistant::append_fight(const std::string& stage, int mecidine, int stone, int times)
{
LogTraceFunction;
if (!m_inited) {
return false;
std::shared_ptr<PackageTask> ptr = nullptr;
if (type == "Fight") {
ptr = std::make_shared<FightTask>(task_callback, (void*)this);
ptr->set_params(ret.value());
}
constexpr const char* TaskChain = "Fight";
// 进入选关界面（主界面的“终端”点进去）
auto terminal_task_ptr = std::make_shared<ProcessTask>(task_callback, (void*)this, TaskChain);
terminal_task_ptr->set_tasks({ "StageBegin" })
.set_times_limit("GoLastBattle", 0)
.set_times_limit("StartButton1", 0)
.set_times_limit("StartButton2", 0)
.set_times_limit("MedicineConfirm", 0)
.set_times_limit("StoneConfirm", 0);
// 进入对应的关卡
auto stage_task_ptr = std::make_shared<ProcessTask>(task_callback, (void*)this, TaskChain);
stage_task_ptr->set_tasks({ stage })
.set_times_limit("StartButton1", 0)
.set_times_limit("StartButton2", 0)
.set_times_limit("MedicineConfirm", 0)
.set_times_limit("StoneConfirm", 0);
// 开始战斗任务
auto fight_task_ptr = std::make_shared<ProcessTask>(task_callback, (void*)this, TaskChain);
fight_task_ptr->set_tasks({ "FightBegin" })
.set_times_limit("MedicineConfirm", mecidine)
.set_times_limit("StoneConfirm", stone)
.set_times_limit("StartButton1", times)
.set_times_limit("StartButton2", times);
fight_task_ptr->regiseter_plugin<StageDropsTaskPlugin>()
->set_retry_times(0);
std::unique_lock<std::mutex> lock(m_mutex);
if (!stage.empty()) {
m_tasks_queue.emplace(terminal_task_ptr);
m_tasks_queue.emplace(stage_task_ptr);
}
m_tasks_queue.emplace(fight_task_ptr);
return true;
}
bool asst::Assistant::append_award()
{
std::unique_lock<std::mutex> lock(m_mutex);
return append_process_task("AwardBegin", "Award");
}
bool asst::Assistant::append_visit()
{
std::unique_lock<std::mutex> lock(m_mutex);
return append_process_task("VisitBegin", "Visit");
}
bool asst::Assistant::append_mall(bool with_shopping)
{
LogTraceFunction;
if (!m_inited) {
return false;
}
const std::string TaskChain = "Mall";
std::unique_lock<std::mutex> lock(m_mutex);
append_process_task("MallBegin", TaskChain);
if (with_shopping) {
auto shopping_task_ptr = std::make_shared<CreditShoppingTask>(task_callback, (void*)this, TaskChain);
m_tasks_queue.emplace(shopping_task_ptr);
}
return true;
}
bool Assistant::append_process_task(const std::string& task_name, std::string task_chain, int retry_times)
{
LogTraceFunction;
if (!m_inited) {
return false;
}
//std::unique_lock<std::mutex> lock(m_mutex);
if (task_chain.empty()) {
task_chain = task_name;
}
auto task_ptr = std::make_shared<ProcessTask>(task_callback, (void*)this, task_chain);
task_ptr->set_tasks({ task_name })
.set_retry_times(retry_times);
m_tasks_queue.emplace(task_ptr);
return true;
}
bool asst::Assistant::append_recruit(unsigned max_times, const std::vector<int>& select_level, const std::vector<int>& confirm_level, bool need_refresh, bool use_expedited)
{
LogTraceFunction;
if (!m_inited) {
return false;
}
constexpr static const char* TaskChain = "Recruit";
auto recruit_task_ptr = std::make_shared<AutoRecruitTask>(task_callback, (void*)this, TaskChain);
recruit_task_ptr->set_max_times(max_times)
.set_need_refresh(need_refresh)
.set_use_expedited(use_expedited)
.set_select_level(select_level)
.set_confirm_level(confirm_level)
.set_retry_times(AutoRecruitTaskRetryTimesDefault);
std::unique_lock<std::mutex> lock(m_mutex);
append_process_task("RecruitBegin", TaskChain);
m_tasks_queue.emplace(recruit_task_ptr);
return true;
}
bool asst::Assistant::append_roguelike(int mode)
{
LogTraceFunction;
if (!m_inited) {
return false;
}
constexpr static const char* RoguelikeTaskChain = "Roguelike";
auto roguelike_task_ptr = std::make_shared<ProcessTask>(task_callback, (void*)this, RoguelikeTaskChain);
roguelike_task_ptr->set_tasks({ "Roguelike1Begin" })
.set_retry_times(50);
switch (mode) {
case 0:
break;
case 1:
roguelike_task_ptr->set_times_limit("Roguelike1StageTraderLeave", 0);
break;
case 2:
roguelike_task_ptr->set_times_limit("Roguelike1StageTraderInvestCancel", 0);
break;
default:
return false;
}
roguelike_task_ptr->regiseter_plugin<RoguelikeFormationTaskPlugin>();
roguelike_task_ptr->regiseter_plugin<RoguelikeBattleTaskPlugin>();
std::unique_lock<std::mutex> lock(m_mutex);
// 这个任务如果卡住会放弃当前的肉鸽并重新开始，所以多添加一点。先这样凑合用
for (int i = 0; i != 10000; ++i) {
m_tasks_queue.emplace(roguelike_task_ptr);
}
return true;
}
#ifdef ASST_DEBUG
bool Assistant::append_debug()
{
LogTraceFunction;
if (!m_inited) {
return false;
else if (type == "StartUp") {
ptr = std::make_shared<StartUpTask>(task_callback, (void*)this);
ptr->set_params(ret.value());
}
std::unique_lock<std::mutex> lock(m_mutex);
{
constexpr static const char* DebugTaskChain = "Debug";
auto debug_task_ptr = std::make_shared<RoguelikeBattleTaskPlugin>(task_callback, (void*)this, DebugTaskChain);
debug_task_ptr->set_stage_name("暴君");
m_tasks_queue.emplace(debug_task_ptr);
}
return true;
return m_tasks_queue.emplace(ptr).get();
}
#endif
bool Assistant::start_recruit_calc(const std::vector<int>& select_level, bool set_time)
bool asst::Assistant::set_task_params(PackageTask* handle, const std::string& params)
{
LogTraceFunction;
if (!m_inited) {
Log.info(__FUNCTION__, handle, params);
if (!handle) {
return false;
}
auto task_ptr = std::make_shared<RecruitTask>(task_callback, (void*)this, "RecruitCalc");
task_ptr->set_retry_times(OpenRecruitTaskRetryTimesDefault);
task_ptr->set_param(select_level, set_time);
std::unique_lock<std::mutex> lock(m_mutex);
m_tasks_queue.emplace(task_ptr);
return start(false);
}
bool asst::Assistant::append_infrast(infrast::WorkMode work_mode, const std::vector<std::string>& order, const std::string& uses_of_drones, double dorm_threshold)
{
LogTraceFunction;
if (!m_inited) {
auto ret = json::parse(params);
if (!ret) {
return false;
}
// 保留接口，目前强制按激进模式进行换班
work_mode = infrast::WorkMode::Aggressive;
// TODO: 检查任务句柄合法性
constexpr static const char* InfrastTaskCahin = "Infrast";
constexpr int InfrastRetryTimes = 3;
// 这个流程任务，结束的时候是处于基建主界面的。既可以用于进入基建，也可以用于从设施里返回基建主界面
auto append_infrast_begin = [&]() {
append_process_task("InfrastBegin", InfrastTaskCahin);
};
append_infrast_begin();
auto info_task_ptr = std::make_shared<InfrastInfoTask>(task_callback, (void*)this, InfrastTaskCahin);
info_task_ptr->set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
m_tasks_queue.emplace(info_task_ptr);
// 因为后期要考虑多任务间的联动等，所以这些任务的声明暂时不放到for循环中
auto mfg_task_ptr = std::make_shared<InfrastMfgTask>(task_callback, (void*)this, InfrastTaskCahin);
mfg_task_ptr->set_uses_of_drone(uses_of_drones)
.set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
auto trade_task_ptr = std::make_shared<InfrastTradeTask>(task_callback, (void*)this, InfrastTaskCahin);
trade_task_ptr->set_uses_of_drone(uses_of_drones)
.set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
trade_task_ptr->regiseter_plugin<DronesForShamareTaskPlugin>();
auto power_task_ptr = std::make_shared<InfrastPowerTask>(task_callback, (void*)this, InfrastTaskCahin);
power_task_ptr->set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
auto office_task_ptr = std::make_shared<InfrastOfficeTask>(task_callback, (void*)this, InfrastTaskCahin);
office_task_ptr->set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
auto recpt_task_ptr = std::make_shared<InfrastReceptionTask>(task_callback, (void*)this, InfrastTaskCahin);
recpt_task_ptr->set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold);
auto control_task_ptr = std::make_shared<InfrastControlTask>(task_callback, (void*)this, InfrastTaskCahin);
control_task_ptr->set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
auto dorm_task_ptr = std::make_shared<InfrastDormTask>(task_callback, (void*)this, InfrastTaskCahin);
dorm_task_ptr->set_work_mode(work_mode)
.set_mood_threshold(dorm_threshold)
.set_retry_times(InfrastRetryTimes);
std::unique_lock<std::mutex> lock(m_mutex);
for (const auto& facility : order) {
if (facility == "Dorm") {
m_tasks_queue.emplace(dorm_task_ptr);
}
else if (facility == "Mfg") {
m_tasks_queue.emplace(mfg_task_ptr);
}
else if (facility == "Trade") {
m_tasks_queue.emplace(trade_task_ptr);
}
else if (facility == "Power") {
m_tasks_queue.emplace(power_task_ptr);
}
else if (facility == "Office") {
m_tasks_queue.emplace(office_task_ptr);
}
else if (facility == "Reception") {
m_tasks_queue.emplace(recpt_task_ptr);
}
else if (facility == "Control") {
m_tasks_queue.emplace(control_task_ptr);
}
else {
Log.error("append_infrast | Unknown facility", facility);
}
append_infrast_begin();
}
return true;
return handle->set_params(ret.value());
}
std::vector<uchar> asst::Assistant::get_image() const
@@ -623,13 +326,13 @@ bool asst::Assistant::set_penguid_id(const json::value& root)
bool asst::Assistant::set_ocr_text(const json::value& root)
{
bool ret = true;
for (auto&& [key, text] : root.as_object()) {
if (!text.is_array()) {
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.as_array()) {
for (auto&& text : text_arr.as_array()) {
if (!text.is_string()) {
Log.error("Json Field error");
return false;