diff --git a/docs/集成文档.md b/docs/集成文档.md
index 432206645e..409d8b1e8d 100644
--- a/docs/集成文档.md
+++ b/docs/集成文档.md
@@ -2,6 +2,56 @@
 
 ## 接口介绍
 
+### `AsstAppendTask`
+
+#### 接口原型
+
+```c++
+TaskHandle ASSTAPI AsstAppendTask(AsstHandle handle, const char* type, const char* params);
+```
+
+#### 接口说明
+
+添加任务
+
+#### 返回值
+
+- `TaskHandle`  
+    若添加成功，返回该任务句柄，可用于后续设置任务参数；  
+    若添加失败，返回 `NULL`
+
+#### 参数说明
+
+- `AsstHandle handle`  
+    实例句柄
+- `const char* type`  
+    任务类型
+- `const char* params`  
+    任务参数，json string
+
+##### 字段举例
+
+- `StartUp`  
+    开始唤醒
+
+```jsonc
+{
+    // 不支持参数设置
+}
+```
+
+- `Fight`  
+    刷理智
+
+```jsonc
+{
+    "stage": string, // 关卡名，可选，默认“当前关卡”。不支持运行中设置
+    "mecidine": int, // 最大使用理智药数量，可选，默认 0
+    "stone": int,    // 最大吃石头数量，可选，默认 0
+    "times": int,    // 指定次数，可选，默认无穷大
+}
+```
+
 ### `AsstSetParam`
 
 #### 接口原型
@@ -31,4 +81,4 @@ bool ASSTAPI AsstSetParam(AsstHandle handle, const char* param_id, const char* p
 | 参数作用 | 参数 id | 参数值 | 参数值示例 |
 | ------- | ------- | ----- | -------- |
 | 设置企鹅数据 id | `penguin_id` | { "id" : string } | `{ "id" : "1234567" }` |
-| 设置 OCR 任务目标 | `ocr_text` | { TaskName: [ string, ... ] } | `{ "Roguelike1ChooseOper" : [ "帕拉斯", "银灰" ] }` |
+| 设置 OCR 任务目标 | `ocr_text` | { TaskName: [ string, ... ] } | `{ "Roguelike1ChooseOper" : [ "帕拉斯", "银灰" ] }`<br>`{ "CreditShop-NotToBuy" : [ "碳", "家具" ] }` |
diff --git a/include/AsstCaller.h b/include/AsstCaller.h
index 9da5496e50..4fd901747c 100644
--- a/include/AsstCaller.h
+++ b/include/AsstCaller.h
@@ -5,34 +5,27 @@
 namespace asst
 {
     class Assistant;
+    class PackageTask;
 }
 
 #ifdef __cplusplus
 extern "C" {
 #endif
     typedef asst::Assistant* AsstHandle;
+    typedef asst::PackageTask* TaskHandle;
     typedef void(ASST_CALL* AsstApiCallback)(int msg, const char* detail_json, void* custom_arg);
 
     bool ASSTAPI AsstLoadResource(const char* path);
+
     ASSTAPI_PORT AsstHandle ASST_CALL AsstCreate();
     ASSTAPI_PORT AsstHandle ASST_CALL AsstCreateEx(AsstApiCallback callback, void* custom_arg);
     void ASSTAPI AsstDestroy(AsstHandle handle);
 
     bool ASSTAPI AsstConnect(AsstHandle handle, const char* adb_path, const char* address, const char* config);
 
-    bool ASSTAPI AsstAppendStartUp(AsstHandle handle);
-    bool ASSTAPI AsstAppendFight(AsstHandle handle, const char* stage, int max_mecidine, int max_stone, int max_times);
-    bool ASSTAPI AsstAppendAward(AsstHandle handle);
-    bool ASSTAPI AsstAppendVisit(AsstHandle handle);
-    bool ASSTAPI AsstAppendMall(AsstHandle handle, bool with_shopping);
-    // bool ASSTAPI AsstAppendProcessTask(AsstHandle handle, const char* task_name);
-    bool ASSTAPI AsstAppendInfrast(AsstHandle handle, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold);
-    bool ASSTAPI AsstAppendRecruit(AsstHandle handle, int max_times, const int select_level[], int select_len, const int confirm_level[], int confirm_len, bool need_refresh, bool use_expedited);
-    bool ASSTAPI AsstAppendRoguelike(AsstHandle handle, int mode);
+    TaskHandle ASSTAPI AsstAppendTask(AsstHandle handle, const char* type, const char* params);
+    bool ASSTAPI AsstSetTaskParams(AsstHandle handle, TaskHandle task, const char* params);
 
-    bool ASSTAPI AsstAppendDebug(AsstHandle handle);
-
-    bool ASSTAPI AsstStartRecruitCalc(AsstHandle handle, const int select_level[], int required_len, bool set_time);
     bool ASSTAPI AsstStart(AsstHandle handle);
     bool ASSTAPI AsstStop(AsstHandle handle);
 
@@ -42,7 +35,6 @@ extern "C" {
     bool ASSTAPI AsstCtrlerClick(AsstHandle handle, int x, int y, bool block);
 
     ASSTAPI_PORT const char* ASST_CALL AsstGetVersion();
-
     void ASSTAPI AsstLog(const char* level, const char* message);
 
 #ifdef __cplusplus
diff --git a/src/MeoAssistant/AbstractTask.h b/src/MeoAssistant/AbstractTask.h
index e02feb8f5e..d388249b9e 100644
--- a/src/MeoAssistant/AbstractTask.h
+++ b/src/MeoAssistant/AbstractTask.h
@@ -31,11 +31,11 @@ namespace asst
 
         virtual bool run();
 
-        AbstractTask& set_exit_flag(bool* exit_flag) noexcept;
-        AbstractTask& set_retry_times(int times) noexcept;
-        AbstractTask& set_ctrler(std::shared_ptr<Controller> ctrler) noexcept;
-        AbstractTask& set_status(std::shared_ptr<RuntimeStatus> status) noexcept;
-        AbstractTask& set_task_data(std::shared_ptr<TaskData> task_data) noexcept;
+        virtual AbstractTask& set_exit_flag(bool* exit_flag) noexcept;
+        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()
diff --git a/src/MeoAssistant/Assistant.cpp b/src/MeoAssistant/Assistant.cpp
index 7e049d67e6..0993a9a45f 100644
--- a/src/MeoAssistant/Assistant.cpp
+++ b/src/MeoAssistant/Assistant.cpp
@@ -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;
diff --git a/src/MeoAssistant/Assistant.h b/src/MeoAssistant/Assistant.h
index 8838a093e5..14bed6767e 100644
--- a/src/MeoAssistant/Assistant.h
+++ b/src/MeoAssistant/Assistant.h
@@ -26,6 +26,7 @@ namespace asst
     class Identify;
     class Controller;
     class TaskData;
+    class PackageTask;
 
     class Assistant
     {
@@ -36,42 +37,8 @@ namespace asst
         // 连接adb
         bool connect(const std::string& adb_path, const std::string& address, const std::string& config);
 
-        // 添加开始游戏的任务（进入到主界面）
-        bool append_start_up();
-        // 添加刷理智任务
-        bool append_fight(const std::string& stage, int mecidine = 0, int stone = 0, int times = INT_MAX);
-        // 添加领取日常任务奖励任务
-        bool append_award();
-        // 添加访问好友任务
-        bool append_visit();
-        // 添加领取当日信用及信用购的任务
-        bool append_mall(bool with_shopping);
-
-        // 添加基建换班任务任务
-        bool append_infrast(infrast::WorkMode work_mode, const std::vector<std::string>& order, const std::string& uses_of_drones, double dorm_threshold);
-
-        // 添加自动公招任务
-        // 参数 max_times: 最多进行几次公招
-        // 参数 select_level: 需要的选择Tags的等级
-        // 参数 confirm_level: 需要点击确认按钮的等级
-        // 参数 need_refresh: 是否刷新 3 星 Tags
-        // 参数 use_expedited: 是否使用加急券
-        bool append_recruit(unsigned max_times, const std::vector<int>& select_level, const std::vector<int>& confirm_level, bool need_refresh, bool use_expedited);
-
-        /*** 添加自动肉鸽任务
-        * mode: 0 - 尽可能一直往后打
-        *       1 - 第一层投资完源石锭就退出
-        *       2 - 投资过后再退出，没有投资就继续往后打
-        ***/
-        bool append_roguelike(int mode);
-
-#ifdef ASST_DEBUG
-        // 调试用
-        bool append_debug();
-#endif
-
-        // 开始公开招募计算
-        bool start_recruit_calc(const std::vector<int>& select_level, bool set_time);
+        PackageTask* append_task(const std::string& type, const std::string& params);
+        bool set_task_params(PackageTask* handle, const std::string& params);
 
         // 开始执行任务队列
         bool start(bool block = true);
@@ -108,7 +75,7 @@ namespace asst
         std::shared_ptr<TaskData> m_task_data = nullptr;
 
         bool m_thread_exit = false;
-        std::queue<std::shared_ptr<AbstractTask>> m_tasks_queue;
+        std::queue<std::shared_ptr<PackageTask>> m_tasks_queue;
         AsstApiCallback m_callback = nullptr;
         void* m_callback_arg = nullptr;
 
diff --git a/src/MeoAssistant/AsstCaller.cpp b/src/MeoAssistant/AsstCaller.cpp
index 16467c93a0..229bce02ec 100644
--- a/src/MeoAssistant/AsstCaller.cpp
+++ b/src/MeoAssistant/AsstCaller.cpp
@@ -79,106 +79,6 @@ bool AsstConnect(AsstHandle handle, const char* adb_path, const char* address, c
     return handle->connect(adb_path, address, config ? config : std::string());
 }
 
-bool AsstAppendStartUp(AsstHandle handle)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-
-    return handle->append_start_up();
-}
-
-bool AsstAppendFight(AsstHandle handle, const char* stage, int max_mecidine, int max_stone, int max_times)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-
-    return handle->append_fight(stage, max_mecidine, max_stone, max_times);
-}
-
-bool AsstAppendAward(AsstHandle handle)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-
-    return handle->append_award();
-}
-
-bool AsstAppendVisit(AsstHandle handle)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-
-    return handle->append_visit();
-}
-
-bool AsstAppendMall(AsstHandle handle, bool with_shopping)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-
-    return handle->append_mall(with_shopping);
-}
-
-//bool AsstAppendProcessTask(AsstHandle handle, const char* task_name)
-//{
-//    if (!inited || handle == nullptr) {
-//        return false;
-//    }
-//
-//    return handle->append_process_task(task_name);
-//}
-
-bool AsstStartRecruitCalc(AsstHandle handle, const int select_level[], int required_len, bool set_time)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-    std::vector<int> level_vector;
-    level_vector.assign(select_level, select_level + required_len);
-    return handle->start_recruit_calc(level_vector, set_time);
-}
-
-bool AsstAppendInfrast(AsstHandle handle, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-    std::vector<std::string> order_vector;
-    order_vector.assign(order, order + order_size);
-
-    return handle->append_infrast(
-        static_cast<asst::infrast::WorkMode>(work_mode),
-        order_vector,
-        uses_of_drones,
-        dorm_threshold);
-}
-
-bool AsstAppendRecruit(AsstHandle handle, int max_times, const int select_level[], int select_len, const int confirm_level[], int confirm_len, bool need_refresh, bool use_expedited)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-    std::vector<int> required_vector;
-    required_vector.assign(select_level, select_level + select_len);
-    std::vector<int> confirm_vector;
-    confirm_vector.assign(confirm_level, confirm_level + confirm_len);
-
-    return handle->append_recruit(max_times, required_vector, confirm_vector, need_refresh, use_expedited);
-}
-
-bool AsstAppendRoguelike(AsstHandle handle, int mode)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-    return handle->append_roguelike(mode);
-}
-
 bool AsstStart(AsstHandle handle)
 {
     if (!inited || handle == nullptr) {
@@ -206,6 +106,23 @@ bool AsstSetParam(AsstHandle handle, const char* param_id, const char* param_val
     return handle->set_param(param_id, param_value);
 }
 
+TaskHandle ASSTAPI AsstAppendTask(AsstHandle handle, const char* type, const char* params)
+{
+    if (!inited || handle == nullptr) {
+        return nullptr;
+    }
+
+    return handle->append_task(type, params);
+}
+
+bool ASSTAPI AsstSetTaskParams(AsstHandle handle, TaskHandle task, const char* params)
+{
+    if (!inited || task == nullptr || handle == nullptr) {
+        return false;
+    }
+    return handle->set_task_params(task, params);
+}
+
 unsigned long long AsstGetImage(AsstHandle handle, void* buff, unsigned long long buff_size)
 {
     if (!inited || handle == nullptr || buff == nullptr) {
@@ -250,15 +167,3 @@ void AsstLog(const char* level, const char* message)
     }
     asst::Log.log_with_custom_level(level, message);
 }
-
-bool AsstAppendDebug(AsstHandle handle)
-{
-    if (!inited || handle == nullptr) {
-        return false;
-    }
-#ifdef ASST_DEBUG
-    return handle->append_debug();
-#else
-    return false;
-#endif // ASST_DEBUG
-}
diff --git a/src/MeoAssistant/AutoRecruitTask.cpp b/src/MeoAssistant/AutoRecruitTask.cpp
index 84936f5767..86345653da 100644
--- a/src/MeoAssistant/AutoRecruitTask.cpp
+++ b/src/MeoAssistant/AutoRecruitTask.cpp
@@ -81,6 +81,7 @@ 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);
 
     auto image = m_ctrler->get_image();
     start_analyzer.set_image(image);
diff --git a/src/MeoAssistant/BattleImageAnalyzer.cpp b/src/MeoAssistant/BattleImageAnalyzer.cpp
index a368ebb4ed..e8cc075abb 100644
--- a/src/MeoAssistant/BattleImageAnalyzer.cpp
+++ b/src/MeoAssistant/BattleImageAnalyzer.cpp
@@ -51,6 +51,7 @@ bool asst::BattleImageAnalyzer::opers_analyze()
 
     MultiMatchImageAnalyzer flags_analyzer(m_image);
     flags_analyzer.set_task_info(m_task_data->get("BattleOpersFlag"));
+    flags_analyzer.set_task_data(m_task_data);
     if (!flags_analyzer.analyze()) {
         return false;
     }
@@ -104,6 +105,7 @@ 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;
@@ -161,6 +163,7 @@ int asst::BattleImageAnalyzer::oper_cost_analyze(const Rect& roi)
                 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);
@@ -254,6 +257,7 @@ bool asst::BattleImageAnalyzer::skill_analyze()
     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;
@@ -269,6 +273,7 @@ bool asst::BattleImageAnalyzer::hp_analyze()
     // 识别 HP 的那个蓝白色图标
     auto flag_task_ptr = m_task_data->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()) {
         // 漏怪的时候，那个图标会变成红色的，所以多识别一次
@@ -304,6 +309,7 @@ bool asst::BattleImageAnalyzer::hp_analyze()
                 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);
diff --git a/src/MeoAssistant/CreditShopImageAnalyzer.cpp b/src/MeoAssistant/CreditShopImageAnalyzer.cpp
index d58d192de3..d6ffa2de48 100644
--- a/src/MeoAssistant/CreditShopImageAnalyzer.cpp
+++ b/src/MeoAssistant/CreditShopImageAnalyzer.cpp
@@ -26,6 +26,7 @@ bool asst::CreditShopImageAnalyzer::commoditys_analyze()
     const auto commodity_task_ptr = m_task_data->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;
@@ -61,6 +62,7 @@ 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(not_to_buy_task_ptr->text);
         if (ocr_analyzer.analyze()) {
             //因为是不买的，有识别结果说明这个商品不买，直接跳过
@@ -80,6 +82,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);
 
     for (const Rect& commodity : m_need_to_buy) {
         sold_out_analyzer.set_roi(commodity);
diff --git a/src/MeoAssistant/CreditShoppingTask.cpp b/src/MeoAssistant/CreditShoppingTask.cpp
index 55eb49ea30..f1ce96c7e6 100644
--- a/src/MeoAssistant/CreditShoppingTask.cpp
+++ b/src/MeoAssistant/CreditShoppingTask.cpp
@@ -16,6 +16,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);
     if (!shop_analyzer.analyze()) {
         return false;
     }
@@ -39,6 +40,7 @@ bool asst::CreditShoppingTask::_run()
 
             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 报错
@@ -59,6 +61,7 @@ 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"));
         if (prompt_analyzer.analyze()) {
             click_return_button();
diff --git a/src/MeoAssistant/FightTask.cpp b/src/MeoAssistant/FightTask.cpp
new file mode 100644
index 0000000000..d7fa786699
--- /dev/null
+++ b/src/MeoAssistant/FightTask.cpp
@@ -0,0 +1,62 @@
+#include "FightTask.h"
+
+#include "ProcessTask.h"
+#include "StageDropsTaskPlugin.h"
+
+asst::FightTask::FightTask(AsstCallback callback, void* callback_arg)
+    : PackageTask(callback, callback_arg, TaskChain),
+    m_start_up_task_ptr(std::make_shared<ProcessTask>(m_callback, m_callback_arg, TaskChain)),
+    m_stage_task_ptr(std::make_shared<ProcessTask>(m_callback, m_callback_arg, TaskChain)),
+    m_fight_task_ptr(std::make_shared<ProcessTask>(m_callback, m_callback_arg, TaskChain))
+{
+    // 进入选关界面（主界面的“终端”点进去）
+    m_start_up_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);
+
+    // 进入对应的关卡
+    m_stage_task_ptr->set_times_limit("StartButton1", 0)
+        .set_times_limit("StartButton2", 0)
+        .set_times_limit("MedicineConfirm", 0)
+        .set_times_limit("StoneConfirm", 0);
+
+    // 开始战斗任务
+    m_fight_task_ptr->set_tasks({ "FightBegin" });
+
+    m_fight_task_ptr->regiseter_plugin<StageDropsTaskPlugin>()
+        ->set_retry_times(0);
+}
+
+bool asst::FightTask::set_params(const json::value& params)
+{
+    const std::string stage = params.get("stage", "");
+    const int mecidine = params.get("mecidine", 0);
+    const int stone = params.get("stone", 0);
+    const int times = params.get("times", INT_MAX);
+
+    if (!runned) {
+        m_stage_task_ptr->set_tasks({ stage });
+        m_fight_task_ptr->set_times_limit("MedicineConfirm", mecidine)
+            .set_times_limit("StoneConfirm", stone)
+            .set_times_limit("StartButton1", times)
+            .set_times_limit("StartButton2", times);
+
+        m_subtasks.clear();
+
+        if (!stage.empty()) {
+            m_subtasks.emplace_back(m_start_up_task_ptr);
+            m_subtasks.emplace_back(m_stage_task_ptr);
+        }
+        m_subtasks.emplace_back(m_fight_task_ptr);
+    }
+    else {
+        m_fight_task_ptr->set_times_limit("MedicineConfirm", mecidine)
+            .set_times_limit("StoneConfirm", stone)
+            .set_times_limit("StartButton1", times)
+            .set_times_limit("StartButton2", times);
+    }
+    return true;
+}
diff --git a/src/MeoAssistant/FightTask.h b/src/MeoAssistant/FightTask.h
new file mode 100644
index 0000000000..2066faec40
--- /dev/null
+++ b/src/MeoAssistant/FightTask.h
@@ -0,0 +1,25 @@
+#pragma once
+#include "PackageTask.h"
+
+#include <memory>
+
+namespace asst
+{
+    class ProcessTask;
+
+    class FightTask : public PackageTask
+    {
+    public:
+        FightTask(AsstCallback callback, void* callback_arg);
+        virtual ~FightTask() = default;
+
+        virtual bool set_params(const json::value& params) override;
+
+        static constexpr const char* TaskChain = "Fight";
+    protected:
+
+        std::shared_ptr<ProcessTask> m_start_up_task_ptr = nullptr;
+        std::shared_ptr<ProcessTask> m_stage_task_ptr = nullptr;
+        std::shared_ptr<ProcessTask> m_fight_task_ptr = nullptr;
+    };
+}
diff --git a/src/MeoAssistant/InfrastAbstractTask.cpp b/src/MeoAssistant/InfrastAbstractTask.cpp
index 6cfa5c9020..3e982768cb 100644
--- a/src/MeoAssistant/InfrastAbstractTask.cpp
+++ b/src/MeoAssistant/InfrastAbstractTask.cpp
@@ -78,6 +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;
diff --git a/src/MeoAssistant/InfrastClueImageAnalyzer.cpp b/src/MeoAssistant/InfrastClueImageAnalyzer.cpp
index b76d4cbc20..c70399aea0 100644
--- a/src/MeoAssistant/InfrastClueImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastClueImageAnalyzer.cpp
@@ -16,7 +16,8 @@ bool asst::InfrastClueImageAnalyzer::analyze()
 bool asst::InfrastClueImageAnalyzer::clue_detect()
 {
     MultiMatchImageAnalyzer clue_analyzer(m_image);
-    clue_analyzer.set_task_info(StaticTaskData::get_instance().get("InfrastClue"));
+    clue_analyzer.set_task_info(m_task_data->get("InfrastClue"));
+    clue_analyzer.set_task_data(m_task_data);
     clue_analyzer.set_roi(m_roi); // 该任务以外部设置的roi为准
     if (!clue_analyzer.analyze()) {
         return false;
diff --git a/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp b/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
index 1bc779a834..c39f278f53 100644
--- a/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastClueVacancyImageAnalyzer.cpp
@@ -10,8 +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(StaticTaskData::get_instance().get(clue_vacancy + suffix));
+        analyzer.set_task_info(m_task_data->get(clue_vacancy + suffix));
         if (!analyzer.analyze()) {
             Log.trace("no", clue_vacancy, suffix);
             continue;
diff --git a/src/MeoAssistant/InfrastDormTask.cpp b/src/MeoAssistant/InfrastDormTask.cpp
index 24dc048edf..2a41341889 100644
--- a/src/MeoAssistant/InfrastDormTask.cpp
+++ b/src/MeoAssistant/InfrastDormTask.cpp
@@ -44,6 +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()) {
diff --git a/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp b/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
index 49fd508752..766cebb269 100644
--- a/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastFacilityImageAnalyzer.cpp
@@ -22,9 +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(StaticTaskData::get_instance().get(task_name));
+        mm_analyzer.set_task_info(m_task_data->get(task_name));
         return mm_analyzer.analyze();
     };
 
diff --git a/src/MeoAssistant/InfrastInfoTask.cpp b/src/MeoAssistant/InfrastInfoTask.cpp
index b0adacdb73..80d6f48768 100644
--- a/src/MeoAssistant/InfrastInfoTask.cpp
+++ b/src/MeoAssistant/InfrastInfoTask.cpp
@@ -12,6 +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;
diff --git a/src/MeoAssistant/InfrastOperImageAnalyzer.cpp b/src/MeoAssistant/InfrastOperImageAnalyzer.cpp
index e003f2da0d..dc962ba405 100644
--- a/src/MeoAssistant/InfrastOperImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastOperImageAnalyzer.cpp
@@ -91,6 +91,7 @@ void asst::InfrastOperImageAnalyzer::oper_detect()
     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);
@@ -210,6 +211,7 @@ void asst::InfrastOperImageAnalyzer::face_hash_analyze()
     const Rect hash_rect_move = m_task_data->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);
@@ -226,6 +228,7 @@ void asst::InfrastOperImageAnalyzer::name_hash_analyze()
         m_task_data->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) {
@@ -245,6 +248,7 @@ void asst::InfrastOperImageAnalyzer::skill_analyze()
     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);
 
@@ -406,6 +410,7 @@ void asst::InfrastOperImageAnalyzer::doing_analyze()
     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) {
diff --git a/src/MeoAssistant/InfrastProductionTask.cpp b/src/MeoAssistant/InfrastProductionTask.cpp
index fffcb6da80..b78eeb42e7 100644
--- a/src/MeoAssistant/InfrastProductionTask.cpp
+++ b/src/MeoAssistant/InfrastProductionTask.cpp
@@ -42,10 +42,12 @@ bool asst::InfrastProductionTask::shift_facility_list()
     }
     const auto tab_task_ptr = m_task_data->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);
     add_analyzer.set_task_info(add_task_ptr);
     MultiMatchImageAnalyzer locked_analyzer;
-    locked_analyzer.set_task_info(StaticTaskData::get_instance().get("InfrastOperLocked" + facility_name()));
+    locked_analyzer.set_task_data(m_task_data);
+    locked_analyzer.set_task_info(m_task_data->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);
@@ -78,11 +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(StaticTaskData::get_instance().get("InfrastFlag" + product));
+            product_analyzer.set_task_info(m_task_data->get("InfrastFlag" + product));
             if (product_analyzer.analyze()) {
                 double score = product_analyzer.get_result().score;
                 if (score > max_score) {
@@ -179,6 +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()) {
@@ -462,6 +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()) {
@@ -619,7 +624,8 @@ bool asst::InfrastProductionTask::facility_list_detect()
 
     const auto image = m_ctrler->get_image();
     MultiMatchImageAnalyzer mm_analyzer(image);
-    mm_analyzer.set_task_info(StaticTaskData::get_instance().get("InfrastFacilityListTab" + facility_name()));
+    mm_analyzer.set_task_data(m_task_data);
+    mm_analyzer.set_task_info(m_task_data->get("InfrastFacilityListTab" + facility_name()));
 
     if (!mm_analyzer.analyze()) {
         return false;
diff --git a/src/MeoAssistant/InfrastReceptionTask.cpp b/src/MeoAssistant/InfrastReceptionTask.cpp
index ad8e77847b..6fe55443ec 100644
--- a/src/MeoAssistant/InfrastReceptionTask.cpp
+++ b/src/MeoAssistant/InfrastReceptionTask.cpp
@@ -65,6 +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()) {
     }
@@ -101,6 +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;
@@ -115,6 +117,7 @@ bool asst::InfrastReceptionTask::proc_clue_vacancy()
         //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;
         }
@@ -142,6 +145,7 @@ 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);
     switch (raw_task_ptr->algorithm) {
diff --git a/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp b/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
index b690d06617..75213618c4 100644
--- a/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
+++ b/src/MeoAssistant/InfrastSmileyImageAnalyzer.cpp
@@ -15,10 +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(StaticTaskData::get_instance().get(task_name));
+        mm_analyzer.set_task_info(m_task_data->get(task_name));
         mm_analyzer.set_roi(m_roi);
         if (!mm_analyzer.analyze()) {
             continue;
diff --git a/src/MeoAssistant/MeoAssistant.vcxproj b/src/MeoAssistant/MeoAssistant.vcxproj
index 5507ee5019..f849f588e9 100644
--- a/src/MeoAssistant/MeoAssistant.vcxproj
+++ b/src/MeoAssistant/MeoAssistant.vcxproj
@@ -27,6 +27,8 @@
     <ClInclude Include="AutoRecruitTask.h" />
     <ClInclude Include="BattleImageAnalyzer.h" />
     <ClInclude Include="BattlePerspectiveImageAnalyzer.h" />
+    <ClInclude Include="FightTask.h" />
+    <ClInclude Include="PackageTask.h" />
     <ClInclude Include="RoguelikeBattleTaskPlugin.h" />
     <ClInclude Include="CreditShopImageAnalyzer.h" />
     <ClInclude Include="DronesForShamareTaskPlugin.h" />
@@ -66,6 +68,7 @@
     <ClInclude Include="RoguelikeFormationImageAnalyzer.h" />
     <ClInclude Include="RuntimeStatus.h" />
     <ClInclude Include="StageDropsTaskPlugin.h" />
+    <ClInclude Include="StartUpTask.h" />
     <ClInclude Include="TaskData.h" />
     <ClInclude Include="MatchImageAnalyzer.h" />
     <ClInclude Include="TemplResource.h" />
@@ -82,6 +85,8 @@
     <ClCompile Include="AutoRecruitTask.cpp" />
     <ClCompile Include="BattleImageAnalyzer.cpp" />
     <ClCompile Include="BattlePerspectiveImageAnalyzer.cpp" />
+    <ClCompile Include="FightTask.cpp" />
+    <ClCompile Include="PackageTask.cpp" />
     <ClCompile Include="RoguelikeBattleTaskPlugin.cpp" />
     <ClCompile Include="CreditShopImageAnalyzer.cpp" />
     <ClCompile Include="CreditShoppingTask.cpp" />
@@ -122,6 +127,7 @@
     <ClCompile Include="RoguelikeFormationImageAnalyzer.cpp" />
     <ClCompile Include="RuntimeStatus.cpp" />
     <ClCompile Include="StageDropsTaskPlugin.cpp" />
+    <ClCompile Include="StartUpTask.cpp" />
     <ClCompile Include="TaskData.cpp" />
     <ClCompile Include="MatchImageAnalyzer.cpp" />
     <ClCompile Include="TemplResource.cpp" />
diff --git a/src/MeoAssistant/MeoAssistant.vcxproj.filters b/src/MeoAssistant/MeoAssistant.vcxproj.filters
index 53f319dce6..5825569fc0 100644
--- a/src/MeoAssistant/MeoAssistant.vcxproj.filters
+++ b/src/MeoAssistant/MeoAssistant.vcxproj.filters
@@ -267,6 +267,15 @@
     <ClInclude Include="RoguelikeFormationImageAnalyzer.h">
       <Filter>头文件\ImageAnalyzer\Final</Filter>
     </ClInclude>
+    <ClInclude Include="PackageTask.h">
+      <Filter>头文件\Task</Filter>
+    </ClInclude>
+    <ClInclude Include="FightTask.h">
+      <Filter>头文件\Task</Filter>
+    </ClInclude>
+    <ClInclude Include="StartUpTask.h">
+      <Filter>头文件\Task</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Controller.cpp">
@@ -428,6 +437,15 @@
     <ClCompile Include="RoguelikeFormationImageAnalyzer.cpp">
       <Filter>源文件\ImageAnalyzer\Final</Filter>
     </ClCompile>
+    <ClCompile Include="PackageTask.cpp">
+      <Filter>源文件\Task</Filter>
+    </ClCompile>
+    <ClCompile Include="FightTask.cpp">
+      <Filter>源文件\Task</Filter>
+    </ClCompile>
+    <ClCompile Include="StartUpTask.cpp">
+      <Filter>源文件\Task</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\resource\config.json">
diff --git a/src/MeoAssistant/PackageTask.cpp b/src/MeoAssistant/PackageTask.cpp
new file mode 100644
index 0000000000..e1b221ac99
--- /dev/null
+++ b/src/MeoAssistant/PackageTask.cpp
@@ -0,0 +1,73 @@
+#include "PackageTask.h"
+
+#include "Resource.h"
+
+bool asst::PackageTask::run()
+{
+    runned = true;
+
+    const auto task_delay = Resrc.cfg().get_options().task_delay;
+
+    for (auto task_ptr : m_subtasks) {
+        if (need_exit()) {
+            return false;
+        }
+
+        task_ptr->set_exit_flag(m_exit_flag)
+            .set_ctrler(m_ctrler)
+            .set_status(m_status)
+            .set_task_data(m_task_data);
+
+        if (!task_ptr->run()) {
+            return false;
+        }
+
+        sleep(task_delay);
+    }
+    return true;
+}
+
+asst::AbstractTask& asst::PackageTask::set_exit_flag(bool* exit_flag) noexcept
+{
+    AbstractTask::set_exit_flag(exit_flag);
+    for (auto&& sub : m_subtasks) {
+        sub->set_exit_flag(exit_flag);
+    }
+    return *this;
+}
+
+asst::AbstractTask& asst::PackageTask::set_retry_times(int times) noexcept
+{
+    AbstractTask::set_retry_times(times);
+    for (auto&& sub : m_subtasks) {
+        sub->set_retry_times(times);
+    }
+    return *this;
+}
+
+asst::AbstractTask& asst::PackageTask::set_ctrler(std::shared_ptr<Controller> ctrler) noexcept
+{
+    AbstractTask::set_ctrler(ctrler);
+    for (auto&& sub : m_subtasks) {
+        sub->set_ctrler(ctrler);
+    }
+    return *this;
+}
+
+asst::AbstractTask& asst::PackageTask::set_status(std::shared_ptr<RuntimeStatus> status) noexcept
+{
+    AbstractTask::set_status(status);
+    for (auto&& sub : m_subtasks) {
+        sub->set_status(status);
+    }
+    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;
+}
diff --git a/src/MeoAssistant/PackageTask.h b/src/MeoAssistant/PackageTask.h
new file mode 100644
index 0000000000..0d9556f0f6
--- /dev/null
+++ b/src/MeoAssistant/PackageTask.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "AbstractTask.h"
+
+#include <queue>
+#include <memory>
+
+namespace json
+{
+    class value;
+}
+
+namespace asst
+{
+    class PackageTask : public AbstractTask
+    {
+    public:
+        using AbstractTask::AbstractTask;
+        virtual ~PackageTask() = default;
+
+        virtual bool run() override;
+
+        virtual bool set_params(const json::value& params) = 0;
+
+        virtual AbstractTask& set_exit_flag(bool* exit_flag) noexcept;
+        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; }
+
+        bool runned = false;
+        std::vector<std::shared_ptr<AbstractTask>> m_subtasks;
+    };
+}
diff --git a/src/MeoAssistant/ProcessTask.cpp b/src/MeoAssistant/ProcessTask.cpp
index 6a9d8eb8a1..eef38baf82 100644
--- a/src/MeoAssistant/ProcessTask.cpp
+++ b/src/MeoAssistant/ProcessTask.cpp
@@ -57,13 +57,13 @@ asst::ProcessTask& asst::ProcessTask::set_tasks(std::vector<std::string> tasks_n
 
 ProcessTask& asst::ProcessTask::set_times_limit(std::string name, int limit)
 {
-    m_times_limit.emplace(std::move(name), limit);
+    m_times_limit[std::move(name)] = limit;
     return *this;
 }
 
 ProcessTask& asst::ProcessTask::set_rear_delay(std::string name, int delay)
 {
-    m_rear_delay.emplace(std::move(name), delay);
+    m_rear_delay[std::move(name)] = delay;
     return *this;
 }
 
@@ -95,7 +95,9 @@ bool ProcessTask::_run()
         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;
             }
diff --git a/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp b/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
index 983ccc5e58..a5e798a308 100644
--- a/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
+++ b/src/MeoAssistant/ProcessTaskImageAnalyzer.cpp
@@ -24,6 +24,7 @@ bool asst::ProcessTaskImageAnalyzer::match_analyze(std::shared_ptr<TaskInfo> tas
         m_match_analyzer = std::make_unique<MatchImageAnalyzer>(m_image);
     }
     const auto match_task_ptr = std::dynamic_pointer_cast<MatchTaskInfo>(task_ptr);
+    m_match_analyzer->set_region_of_appeared(Rect());
     m_match_analyzer->set_task_info(match_task_ptr);
     auto region_opt = m_status->get_region(match_task_ptr->name);
     if (region_opt) {
@@ -72,6 +73,7 @@ bool asst::ProcessTaskImageAnalyzer::ocr_analyze(std::shared_ptr<TaskInfo> task_
     if (!m_ocr_analyzer) {
         m_ocr_analyzer = std::make_unique<OcrImageAnalyzer>(m_image);
     }
+    m_ocr_analyzer->set_region_of_appeared(Rect());
     m_ocr_analyzer->set_task_info(ocr_task_ptr);
     auto region_opt = m_status->get_region(ocr_task_ptr->name);
     if (region_opt) {
diff --git a/src/MeoAssistant/RecruitImageAnalyzer.cpp b/src/MeoAssistant/RecruitImageAnalyzer.cpp
index 37fcd12d1a..c7be7a5f35 100644
--- a/src/MeoAssistant/RecruitImageAnalyzer.cpp
+++ b/src/MeoAssistant/RecruitImageAnalyzer.cpp
@@ -33,6 +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;
@@ -56,6 +57,7 @@ bool asst::RecruitImageAnalyzer::time_analyze()
 
     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;
@@ -75,7 +77,8 @@ bool asst::RecruitImageAnalyzer::time_analyze()
 bool asst::RecruitImageAnalyzer::confirm_analyze()
 {
     MatchImageAnalyzer confirm_analyzer(m_image);
-    confirm_analyzer.set_task_info(StaticTaskData::get_instance().get("RecruitConfirm"));
+    confirm_analyzer.set_task_info(m_task_data->get("RecruitConfirm"));
+    confirm_analyzer.set_task_data(m_task_data);
 
     if (confirm_analyzer.analyze()) {
         m_confirm_rect = confirm_analyzer.get_result().rect;
@@ -88,7 +91,8 @@ bool asst::RecruitImageAnalyzer::confirm_analyze()
 bool asst::RecruitImageAnalyzer::refresh_analyze()
 {
     MatchImageAnalyzer refresh_analyzer(m_image);
-    refresh_analyzer.set_task_info(StaticTaskData::get_instance().get("RecruitRefresh"));
+    refresh_analyzer.set_task_data(m_task_data);
+    refresh_analyzer.set_task_info(m_task_data->get("RecruitRefresh"));
 
     if (refresh_analyzer.analyze()) {
         m_refresh_rect = refresh_analyzer.get_result().rect;
diff --git a/src/MeoAssistant/RecruitTask.cpp b/src/MeoAssistant/RecruitTask.cpp
index 3feb9bc288..30a6bbfe72 100644
--- a/src/MeoAssistant/RecruitTask.cpp
+++ b/src/MeoAssistant/RecruitTask.cpp
@@ -18,6 +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;
diff --git a/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp b/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
index cd6129e6c3..b55d6faec0 100644
--- a/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
+++ b/src/MeoAssistant/RoguelikeBattleTaskPlugin.cpp
@@ -66,6 +66,7 @@ bool asst::RoguelikeBattleTaskPlugin::get_stage_info()
         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,6 +135,7 @@ 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);
     if (!battle_analyzer.analyze()) {
         return false;
     }
@@ -293,6 +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();
diff --git a/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp b/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
index 8393130af1..1fc59664f1 100644
--- a/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
+++ b/src/MeoAssistant/RoguelikeFormationImageAnalyzer.cpp
@@ -13,6 +13,7 @@ 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);
     if (!opers_analyzer.analyze()) {
         return false;
     }
diff --git a/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp b/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
index 2866e898f3..8e08a2ab32 100644
--- a/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
+++ b/src/MeoAssistant/RoguelikeFormationTaskPlugin.cpp
@@ -23,6 +23,7 @@ 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);
     if (!formation_analyzer.analyze()) {
         return false;
     }
diff --git a/src/MeoAssistant/StartUpTask.cpp b/src/MeoAssistant/StartUpTask.cpp
new file mode 100644
index 0000000000..da0f21e30d
--- /dev/null
+++ b/src/MeoAssistant/StartUpTask.cpp
@@ -0,0 +1,21 @@
+#include "StartUpTask.h"
+
+#include "ProcessTask.h"
+
+asst::StartUpTask::StartUpTask(AsstCallback callback, void* callback_arg)
+    : PackageTask(callback, callback_arg, TaskChain),
+    m_start_up_task_ptr(std::make_shared<ProcessTask>(m_callback, m_callback_arg, TaskChain))
+{
+    m_start_up_task_ptr->set_tasks({ "StartUp" })
+        .set_times_limit("ReturnToTerminal", 0)
+        .set_times_limit("Terminal", 0);
+}
+
+bool asst::StartUpTask::set_params([[maybe_unused]] const json::value& params)
+{
+    if (!runned) {
+        m_subtasks.clear();
+        m_subtasks.emplace_back(m_start_up_task_ptr);
+    }
+    return true;
+}
diff --git a/src/MeoAssistant/StartUpTask.h b/src/MeoAssistant/StartUpTask.h
new file mode 100644
index 0000000000..3ded043dbb
--- /dev/null
+++ b/src/MeoAssistant/StartUpTask.h
@@ -0,0 +1,21 @@
+#pragma once
+#include "PackageTask.h"
+
+namespace asst
+{
+    class ProcessTask;
+
+    class StartUpTask : public PackageTask
+    {
+    public:
+        StartUpTask(AsstCallback callback, void* callback_arg);
+        virtual ~StartUpTask() = default;
+
+        virtual bool set_params(const json::value& params) override;
+
+        static constexpr const char* TaskChain = "StartUp";
+    protected:
+
+        std::shared_ptr<ProcessTask> m_start_up_task_ptr = nullptr;
+    };
+}
diff --git a/src/MeoAssistant/TaskData.cpp b/src/MeoAssistant/TaskData.cpp
index 1bdd7613b2..b6864ac492 100644
--- a/src/MeoAssistant/TaskData.cpp
+++ b/src/MeoAssistant/TaskData.cpp
@@ -217,7 +217,13 @@ bool asst::StaticTaskData::parse(const json::value& json)
 
 const std::shared_ptr<asst::TaskInfo> asst::TaskData::get(const std::string& name) const noexcept
 {
-    return std::shared_ptr<TaskInfo>();
+    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)
diff --git a/tools/TestCaller/main.cpp b/tools/TestCaller/main.cpp
index b5a02ae530..dd12065bf8 100644
--- a/tools/TestCaller/main.cpp
+++ b/tools/TestCaller/main.cpp
@@ -30,27 +30,15 @@ int main(int argc, char** argv)
         return -1;
     }
 
+    const char* params = R"(
+{
+    "stage": "CE-5"
+}
+)";
+
     char ch = 0;
     while (ch != 'q') {
-        //AsstAppendRoguelike(ptr, 0);
-        //AsstAppendDebug(ptr);
-        AsstAppendStartUp(ptr);
-        //AsstAppendFight(ptr, "CE-5", 0, 0, 99999);
-        // AsstAppendVisit(ptr, true);
-        //{
-        //     const int required[] = { 3, 4, 5, 6 };
-        //     AsstStartRecruitCalc(ptr, required, sizeof(required) / sizeof(int), true);
-        // }
-        //{
-        //    const char* order[] = { "Trade", "Dorm" };
-        //    AsstAppendInfrast(ptr, 1, order, 2, "Money", 0.3);
-        //}
-        // AsstAppendProcessTask(ptr, "AwardBegin");
-        //{
-        //    const int required[] = { 4 };
-        //    const int confirm[] = { 3, 4 };
-        //    AsstAppendRecruit(ptr, 3, required, sizeof(required) / sizeof(int), confirm, sizeof(confirm) / sizeof(int), true, true);
-        //}
+        AsstAppendTask(ptr, "Fight", params);
         AsstStart(ptr);
 
         ch = static_cast<char>(getchar());