fix.修复热更新资源错误的问题

解决低等级宿舍无法识别问题

.gitignore

@@ -427,4 +427,6 @@ FodyWeavers.xsd
 *.sln.iml
 
 screen.png
-adb_screen.png
+adb_screen.png
+tools/*.png
+resource/infrast

3rdparty/include/calculator/calculator.hpp

@@ -0,0 +1,462 @@
+///
+/// @file      calculator.hpp
+/// @brief     calculator::eval(const std::string&) evaluates an integer
+///            arithmetic expression and returns the result. If an error
+///            occurs a calculator::error exception is thrown.
+///            <https://github.com/kimwalisch/calculator>
+/// @author    Kim Walisch, <kim.walisch@gmail.com>
+/// @copyright Copyright (C) 2013-2018 Kim Walisch
+/// @license   BSD 2-Clause, https://opensource.org/licenses/BSD-2-Clause
+/// @version   1.4
+///
+/// == Supported operators ==
+///
+/// OPERATOR    NAME                     ASSOCIATIVITY    PRECEDENCE
+///
+/// |           Bitwise Inclusive OR    Left               4
+/// ^           Bitwise Exclusive OR    Left               5
+/// &           Bitwise AND             Left               6
+/// <<          Shift Left              Left               9
+/// >>          Shift Right             Left               9
+/// +           Addition                Left              10
+/// -           Subtraction             Left              10
+/// *           Multiplication          Left              20
+/// /           Division                Left              20
+/// %           Modulo                  Left              20
+/// **          Raise to power          Right             30
+/// e, E        Scientific notation     Right             40
+/// ~           Unary complement        Left              99
+///
+/// The operator precedence has been set according to (uses the C and
+/// C++ operator precedence): https://en.wikipedia.org/wiki/Order_of_operations
+/// Operators with higher precedence are evaluated before operators
+/// with relatively lower precedence. Unary operators are set to have
+/// the highest precedence, this is not strictly correct for the power
+/// operator e.g. "-3**2" = 9 but a lot of software tools (Bash shell,
+/// Microsoft Excel, GNU bc, ...) use the same convention.
+///
+/// == Examples of valid expressions ==
+///
+/// "65536 >> 15"                       = 2
+/// "2**16"                             = 65536
+/// "(0 + 0xDf234 - 1000)*3/2%999"      = 828
+/// "-(2**2**2**2)"                     = -65536
+/// "(0 + ~(0xDF234 & 1000) *3) /-2"    = 817
+/// "(2**16) + (1 << 16) >> 0X5"        = 4096
+/// "5*-(2**(9+7))/3+5*(1 & 0xFf123)"   = -109221
+///
+/// == About the algorithm used ==
+///
+/// calculator::eval(std::string&) relies on the ExpressionParser
+/// class which is a simple C++ operator precedence parser with infix
+/// notation for integer arithmetic expressions.
+/// ExpressionParser has its roots in a JavaScript parser published
+/// at: http://stackoverflow.com/questions/28256/equation-expression-parser-with-precedence/114961#114961
+/// The same author has also published an article about his operator
+/// precedence algorithm at PerlMonks:
+/// http://www.perlmonks.org/?node_id=554516
+///
+
+#ifndef CALCULATOR_HPP
+#define CALCULATOR_HPP
+
+#include <stdexcept>
+#include <string>
+#include <sstream>
+#include <stack>
+#include <cstddef>
+#include <cctype>
+
+namespace calculator
+{
+
+/// calculator::eval() throws a calculator::error if it fails
+/// to evaluate the expression string.
+///
+class error : public std::runtime_error
+{
+public:
+  error(const std::string& expr, const std::string& message)
+    : std::runtime_error(message),
+      expr_(expr)
+  { }
+#if __cplusplus < 201103L
+  ~error() throw() { }
+#endif
+  std::string expression() const
+  {
+    return expr_;
+  }
+private:
+  std::string expr_;
+};
+
+template <typename T>
+class ExpressionParser
+{
+public:
+  /// Evaluate an integer arithmetic expression and return its result.
+  /// @throw error if parsing fails.
+  ///
+  T eval(const std::string& expr)
+  {
+    T result = 0;
+    index_ = 0;
+    expr_ = expr;
+    try
+    {
+      result = parseExpr();
+      if (!isEnd())
+        unexpected();
+    }
+    catch (const calculator::error&)
+    {
+      while(!stack_.empty())
+        stack_.pop();
+      throw;
+    }
+    return result;
+  }
+
+  /// Get the integer value of a character.
+  T eval(char c)
+  {
+    std::string expr(1, c);
+    return eval(expr);
+  }
+
+private:
+  enum
+  {
+    OPERATOR_NULL,
+    OPERATOR_BITWISE_OR,     /// |
+    OPERATOR_BITWISE_XOR,    /// ^
+    OPERATOR_BITWISE_AND,    /// &
+    OPERATOR_BITWISE_SHL,    /// <<
+    OPERATOR_BITWISE_SHR,    /// >>
+    OPERATOR_ADDITION,       /// +
+    OPERATOR_SUBTRACTION,    /// -
+    OPERATOR_MULTIPLICATION, /// *
+    OPERATOR_DIVISION,       /// /
+    OPERATOR_MODULO,         /// %
+    OPERATOR_POWER,          /// **
+    OPERATOR_EXPONENT        /// e, E
+  };
+
+  struct Operator
+  {
+    /// Operator, one of the OPERATOR_* enum definitions
+    int op;
+    int precedence;
+    /// 'L' = left or 'R' = right
+    int associativity;
+    Operator(int opr, int prec, int assoc) :
+      op(opr),
+      precedence(prec),
+      associativity(assoc)
+    { }
+  };
+
+  struct OperatorValue
+  {
+    Operator op;
+    T value;
+    OperatorValue(const Operator& opr, T val) :
+      op(opr),
+      value(val)
+    { }
+    int getPrecedence() const
+    {
+      return op.precedence;
+    }
+    bool isNull() const
+    {
+      return op.op == OPERATOR_NULL;
+    }
+  };
+
+  /// Expression string
+  std::string expr_;
+  /// Current expression index, incremented whilst parsing
+  std::size_t index_;
+  /// The current operator and its left value
+  /// are pushed onto the stack if the operator on
+  /// top of the stack has lower precedence.
+  std::stack<OperatorValue> stack_;
+
+  /// Exponentiation by squaring, x^n.
+  static T pow(T x, T n)
+  {
+    T res = 1;
+
+    while (n > 0)
+    {
+      if (n % 2 != 0)
+      {
+        res *= x;
+        n -= 1;
+      }
+      n /= 2;
+
+      if (n > 0)
+        x *= x;
+    }
+
+    return res;
+  }
+
+
+  T checkZero(T value) const
+  {
+    if (value == 0)
+    {
+      std::string divOperators("/%");
+      std::size_t division = expr_.find_last_of(divOperators, index_ - 2);
+      std::ostringstream msg;
+      msg << "Parser error: division by 0";
+      if (division != std::string::npos)
+        msg << " (error token is \""
+            << expr_.substr(division, expr_.size() - division)
+            << "\")";
+      throw calculator::error(expr_, msg.str());
+    }
+    return value;
+  }
+
+  T calculate(T v1, T v2, const Operator& op) const
+  {
+    switch (op.op)
+    {
+      case OPERATOR_BITWISE_OR:     return v1 | v2;
+      case OPERATOR_BITWISE_XOR:    return v1 ^ v2;
+      case OPERATOR_BITWISE_AND:    return v1 & v2;
+      case OPERATOR_BITWISE_SHL:    return v1 << v2;
+      case OPERATOR_BITWISE_SHR:    return v1 >> v2;
+      case OPERATOR_ADDITION:       return v1 + v2;
+      case OPERATOR_SUBTRACTION:    return v1 - v2;
+      case OPERATOR_MULTIPLICATION: return v1 * v2;
+      case OPERATOR_DIVISION:       return v1 / checkZero(v2);
+      case OPERATOR_MODULO:         return v1 % checkZero(v2);
+      case OPERATOR_POWER:          return pow(v1, v2);
+      case OPERATOR_EXPONENT:       return v1 * pow(10, v2);
+      default:                      return 0;
+    }
+  }
+
+  bool isEnd() const
+  {
+    return index_ >= expr_.size();
+  }
+
+  /// Returns the character at the current expression index or
+  /// 0 if the end of the expression is reached.
+  ///
+  char getCharacter() const
+  {
+    if (!isEnd())
+      return expr_[index_];
+    return 0;
+  }
+
+  /// Parse str at the current expression index.
+  /// @throw error if parsing fails.
+  ///
+  void expect(const std::string& str)
+  {
+    if (expr_.compare(index_, str.size(), str) != 0)
+      unexpected();
+    index_ += str.size();
+  }
+
+  void unexpected() const
+  {
+    std::ostringstream msg;
+    msg << "Syntax error: unexpected token \""
+        << expr_.substr(index_, expr_.size() - index_)
+        << "\" at index "
+        << index_;
+    throw calculator::error(expr_, msg.str());
+  }
+
+  /// Eat all white space characters at the
+  /// current expression index.
+  ///
+  void eatSpaces()
+  {
+    while (std::isspace(getCharacter()) != 0)
+      index_++;
+  }
+
+  /// Parse a binary operator at the current expression index.
+  /// @return Operator with precedence and associativity.
+  ///
+  Operator parseOp()
+  {
+    eatSpaces();
+    switch (getCharacter())
+    {
+      case '|': index_++;     return Operator(OPERATOR_BITWISE_OR,      4, 'L');
+      case '^': index_++;     return Operator(OPERATOR_BITWISE_XOR,     5, 'L');
+      case '&': index_++;     return Operator(OPERATOR_BITWISE_AND,     6, 'L');
+      case '<': expect("<<"); return Operator(OPERATOR_BITWISE_SHL,     9, 'L');
+      case '>': expect(">>"); return Operator(OPERATOR_BITWISE_SHR,     9, 'L');
+      case '+': index_++;     return Operator(OPERATOR_ADDITION,       10, 'L');
+      case '-': index_++;     return Operator(OPERATOR_SUBTRACTION,    10, 'L');
+      case '/': index_++;     return Operator(OPERATOR_DIVISION,       20, 'L');
+      case '%': index_++;     return Operator(OPERATOR_MODULO,         20, 'L');
+      case '*': index_++; if (getCharacter() != '*')
+                              return Operator(OPERATOR_MULTIPLICATION, 20, 'L');
+                index_++;     return Operator(OPERATOR_POWER,          30, 'R');
+      case 'e': index_++;     return Operator(OPERATOR_EXPONENT,       40, 'R');
+      case 'E': index_++;     return Operator(OPERATOR_EXPONENT,       40, 'R');
+      default :               return Operator(OPERATOR_NULL,            0, 'L');
+    }
+  }
+
+  static T toInteger(char c)
+  {
+    if (c >= '0' && c <= '9') return c -'0';
+    if (c >= 'a' && c <= 'f') return c -'a' + 0xa;
+    if (c >= 'A' && c <= 'F') return c -'A' + 0xa;
+    T noDigit = 0xf + 1;
+    return noDigit;
+  }
+
+  T getInteger() const
+  {
+    return toInteger(getCharacter());
+  }
+
+  T parseDecimal()
+  {
+    T value = 0;
+    for (T d; (d = getInteger()) <= 9; index_++)
+      value = value * 10 + d;
+    return value;
+  }
+
+  T parseHex()
+  {
+    index_ = index_ + 2;
+    T value = 0;
+    for (T h; (h = getInteger()) <= 0xf; index_++)
+      value = value * 0x10 + h;
+    return value;
+  }
+
+  bool isHex() const
+  {
+    if (index_ + 2 < expr_.size())
+    {
+      char x = expr_[index_ + 1];
+      char h = expr_[index_ + 2];
+      return (std::tolower(x) == 'x' && toInteger(h) <= 0xf);
+    }
+    return false;
+  }
+
+  /// Parse an integer value at the current expression index.
+  /// The unary `+', `-' and `~' operators and opening
+  /// parentheses `(' cause recursion.
+  ///
+  T parseValue()
+  {
+    T val = 0;
+    eatSpaces();
+    switch (getCharacter())
+    {
+      case '0': if (isHex())
+                  val = parseHex();
+                else
+                  val = parseDecimal();
+                break;
+      case '1': case '2': case '3': case '4': case '5':
+      case '6': case '7': case '8': case '9':
+                val = parseDecimal();
+                break;
+      case '(': index_++;
+                val = parseExpr();
+                eatSpaces();
+                if (getCharacter() != ')')
+                {
+                  if (!isEnd())
+                    unexpected();
+                  throw calculator::error(expr_, "Syntax error: `)' expected at end of expression");
+                }
+                index_++; break;
+      case '~': index_++; val = ~parseValue(); break;
+      case '+': index_++; val =  parseValue(); break;
+      case '-': index_++; val =  parseValue() * static_cast<T>(-1);
+                break;
+      default : if (!isEnd())
+                  unexpected();
+                throw calculator::error(expr_, "Syntax error: value expected at end of expression");
+    }
+    return val;
+  }
+
+  /// Parse all operations of the current parenthesis
+  /// level and the levels above, when done
+  /// return the result (value).
+  ///
+  T parseExpr()
+  {
+    stack_.push(OperatorValue(Operator(OPERATOR_NULL, 0, 'L'), 0));
+    // first parse value on the left
+    T value = parseValue();
+
+    while (!stack_.empty())
+    {
+      // parse an operator (+, -, *, ...)
+      Operator op(parseOp());
+      while (op.precedence  < stack_.top().getPrecedence() || (
+             op.precedence == stack_.top().getPrecedence() &&
+             op.associativity == 'L'))
+      {
+        // end reached
+        if (stack_.top().isNull())
+        {
+          stack_.pop();
+          return value;
+        }
+        // do the calculation ("reduce"), producing a new value
+        value = calculate(stack_.top().value, value, stack_.top().op);
+        stack_.pop();
+      }
+
+      // store on stack_ and continue parsing ("shift")
+      stack_.push(OperatorValue(op, value));
+      // parse value on the right
+      value = parseValue();
+    }
+    return 0;
+  }
+};
+
+template <typename T>
+inline T eval(const std::string& expression)
+{
+  ExpressionParser<T> parser;
+  return parser.eval(expression);
+}
+
+template <typename T>
+inline T eval(char c)
+{
+  ExpressionParser<T> parser;
+  return parser.eval(c);
+}
+
+inline int eval(const std::string& expression)
+{
+  return eval<int>(expression);
+}
+
+inline int eval(char c)
+{
+  return eval<int>(c);
+}
+
+} // namespace calculator
+
+#endif

3rdparty/include/meojson/json_aux.h

@@ -5,93 +5,93 @@
 
 namespace json
 {
-	static std::string unescape_string(std::string&& str)
-	{
-		std::string replace_str;
-		std::string escape_str = std::move(str);
+    static std::string unescape_string(std::string&& str)
+    {
+        std::string replace_str;
+        std::string escape_str = std::move(str);
 
-		for (size_t pos = 0; pos < escape_str.size(); ++pos)
-		{
-			switch (escape_str[pos]) {
-			case '\"':
-				replace_str = R"(\")";
-				break;
-			case '\\':
-				replace_str = R"(\\)";
-				break;
-			case '\b':
-				replace_str = R"(\b)";
-				break;
-			case '\f':
-				replace_str = R"(\f)";
-				break;
-			case '\n':
-				replace_str = R"(\n)";
-				break;
-			case '\r':
-				replace_str = R"(\r)";
-				break;
-			case '\t':
-				replace_str = R"(\t)";
-				break;
-			default:
-				continue;
-				break;
-			}
-			escape_str.replace(pos, 1, replace_str);
-			++pos;
-		}
-		return escape_str;
-	}
+        for (size_t pos = 0; pos < escape_str.size(); ++pos)
+        {
+            switch (escape_str[pos]) {
+            case '\"':
+                replace_str = R"(\")";
+                break;
+            case '\\':
+                replace_str = R"(\\)";
+                break;
+            case '\b':
+                replace_str = R"(\b)";
+                break;
+            case '\f':
+                replace_str = R"(\f)";
+                break;
+            case '\n':
+                replace_str = R"(\n)";
+                break;
+            case '\r':
+                replace_str = R"(\r)";
+                break;
+            case '\t':
+                replace_str = R"(\t)";
+                break;
+            default:
+                continue;
+                break;
+            }
+            escape_str.replace(pos, 1, replace_str);
+            ++pos;
+        }
+        return escape_str;
+    }
 
-	static std::string unescape_string(const std::string& str)
-	{
-		return unescape_string(std::string(str));
-	}
+    static std::string unescape_string(const std::string& str)
+    {
+        return unescape_string(std::string(str));
+    }
 
-	static std::string escape_string(std::string&& str)
-	{
-		std::string escape_str = std::move(str);
+    static std::string escape_string(std::string&& str)
+    {
+        std::string escape_str = std::move(str);
 
-		for (size_t pos = 0; pos + 1 < escape_str.size(); ++pos)
-		{
-			if (escape_str[pos] != '\\') {
-				continue;
-			}
-			std::string replace_str;
-			switch (escape_str[pos+1]) {
-			case '"':
-				replace_str = "\"";
-				break;
-			case '\\':
-				replace_str = "\\";
-				break;
-			case 'b':
-				replace_str = "\b";
-				break;
-			case 'f':
-				replace_str = "\f";
-				break;
-			case 'n':
-				replace_str = "\n";
-				break;
-			case 'r':
-				replace_str = "\r";
-				break;
-			case 't':
-				replace_str = "\r";
-				break;
-			default:
-				return std::string();
-				break;
-			}
-			escape_str.replace(pos, 2, replace_str);
-		}
-		return escape_str;
-	}
+        for (size_t pos = 0; pos + 1 < escape_str.size(); ++pos)
+        {
+            if (escape_str[pos] != '\\') {
+                continue;
+            }
+            std::string replace_str;
+            switch (escape_str[pos + 1]) {
+            case '"':
+                replace_str = "\"";
+                break;
+            case '\\':
+                replace_str = "\\";
+                break;
+            case 'b':
+                replace_str = "\b";
+                break;
+            case 'f':
+                replace_str = "\f";
+                break;
+            case 'n':
+                replace_str = "\n";
+                break;
+            case 'r':
+                replace_str = "\r";
+                break;
+            case 't':
+                replace_str = "\t";
+                break;
+            default:
+                return std::string();
+                break;
+            }
+            escape_str.replace(pos, 2, replace_str);
+        }
+        return escape_str;
+    }
 
-	static std::string escape_string(const std::string& str)
-	{
-		return escape_string(std::string(str));
-	}
+    static std::string escape_string(const std::string& str)
+    {
+        return escape_string(std::string(str));
+    }
 }

LICENSE

@@ -1,5 +1,5 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
@@ -7,17 +7,15 @@
 
                             Preamble
 
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
 
   The licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
+our General Public Licenses are intended to guarantee your freedom to
 share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
+software for all its users.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -26,44 +24,34 @@ them if you wish), that you receive source code or can get it if you
 want it, that you can change the software or use pieces of it in new
 free programs, and that you know you can do these things.
 
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
 
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
 
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
 
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
@@ -72,7 +60,7 @@ modification follow.
 
   0. Definitions.
 
-  "This License" refers to version 3 of the GNU General Public License.
+  "This License" refers to version 3 of the GNU Affero General Public License.
 
   "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
@@ -549,35 +537,45 @@ to collect a royalty for further conveying from those to whom you convey
 the Program, the only way you could satisfy both those terms and this
 License would be to refrain entirely from conveying the Program.
 
-  13. Use with the GNU Affero General Public License.
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
 
   Notwithstanding any other provision of this License, you have
 permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
+under version 3 of the GNU General Public License into a single
 combined work, and to convey the resulting work.  The terms of this
 License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
 
   14. Revised Versions of this License.
 
   The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 
   Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
+Program specifies that a certain numbered version of the GNU Affero General
 Public License "or any later version" applies to it, you have the
 option of following the terms and conditions either of that numbered
 version or of any later version published by the Free Software
 Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
+GNU Affero General Public License, you may choose any version ever published
 by the Free Software Foundation.
 
   If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
+versions of the GNU Affero General Public License can be used, that proxy's
 public statement of acceptance of a version permanently authorizes you
 to choose that version for the Program.
 
@@ -635,40 +633,29 @@ the "copyright" line and a pointer to where the full notice is found.
     Copyright (C) <year>  <name of author>
 
     This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+    GNU Affero General Public License for more details.
 
-    You should have received a copy of the GNU General Public License
+    You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
 
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
+For more information on this, and how to apply and follow the GNU AGPL, see
 <https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

MeoAssistance.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30717.126
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31912.275
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MeoAssistance", "src\MeoAssistance\MeoAssistance.vcxproj", "{362D1E30-F5AE-4279-9985-65C27B3BA300}"
 EndProject
@@ -17,30 +17,51 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MeoAsstGui", "src\MeoAsstGu
 		{362D1E30-F5AE-4279-9985-65C27B3BA300} = {362D1E30-F5AE-4279-9985-65C27B3BA300}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TransparentImageCvt", "tools\TransparentImageCvt\TransparentImageCvt.vcxproj", "{093A3174-A27E-4D23-B64E-16F9448AD5AC}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Release|x64 = Release|x64
+		Release|x86 = Release|x86
 		RelWithDebInfo|x64 = RelWithDebInfo|x64
+		RelWithDebInfo|x86 = RelWithDebInfo|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{362D1E30-F5AE-4279-9985-65C27B3BA300}.Release|x64.ActiveCfg = Release|x64
 		{362D1E30-F5AE-4279-9985-65C27B3BA300}.Release|x64.Build.0 = Release|x64
+		{362D1E30-F5AE-4279-9985-65C27B3BA300}.Release|x86.ActiveCfg = Release|x64
 		{362D1E30-F5AE-4279-9985-65C27B3BA300}.RelWithDebInfo|x64.ActiveCfg = RelWithDebInfo|x64
 		{362D1E30-F5AE-4279-9985-65C27B3BA300}.RelWithDebInfo|x64.Build.0 = RelWithDebInfo|x64
+		{362D1E30-F5AE-4279-9985-65C27B3BA300}.RelWithDebInfo|x86.ActiveCfg = RelWithDebInfo|x64
 		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64}.Release|x64.ActiveCfg = Release|x64
 		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64}.Release|x64.Build.0 = Release|x64
+		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64}.Release|x86.ActiveCfg = Release|x64
 		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64}.RelWithDebInfo|x64.ActiveCfg = RelWithDebInfo|x64
 		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64}.RelWithDebInfo|x64.Build.0 = RelWithDebInfo|x64
+		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64}.RelWithDebInfo|x86.ActiveCfg = RelWithDebInfo|x64
 		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.Release|x64.ActiveCfg = Release|Any CPU
 		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.Release|x64.Build.0 = Release|Any CPU
+		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.Release|x86.ActiveCfg = Release|Any CPU
+		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.Release|x86.Build.0 = Release|Any CPU
 		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.RelWithDebInfo|x64.ActiveCfg = RelWithDebInfo|Any CPU
 		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.RelWithDebInfo|x64.Build.0 = RelWithDebInfo|Any CPU
+		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.RelWithDebInfo|x86.ActiveCfg = RelWithDebInfo|Any CPU
+		{FFDC8F49-8EAF-45BE-B0A8-7EF0DB9875A2}.RelWithDebInfo|x86.Build.0 = RelWithDebInfo|Any CPU
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.Release|x64.ActiveCfg = Release|x64
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.Release|x64.Build.0 = Release|x64
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.Release|x86.ActiveCfg = Release|Win32
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.Release|x86.Build.0 = Release|Win32
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.RelWithDebInfo|x64.ActiveCfg = Release|x64
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.RelWithDebInfo|x64.Build.0 = Release|x64
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.RelWithDebInfo|x86.ActiveCfg = Release|Win32
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC}.RelWithDebInfo|x86.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{63B4F1A2-291C-4C85-91E1-A1F6DAE30D64} = {6C4B8D52-51D1-45F8-AAEC-808035443FD6}
+		{093A3174-A27E-4D23-B64E-16F9448AD5AC} = {6C4B8D52-51D1-45F8-AAEC-808035443FD6}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {4F2C0E4B-4FE9-47C6-A878-6BD2FAD8B9B2}

README.md

@@ -1,188 +1,188 @@
 # MeoAssistance
 
+<div>
+    <img alt="C++" src="https://img.shields.io/badge/c++-17-%2300599C?logo=cplusplus">
+    <img alt="VS" src="https://img.shields.io/badge/VisualStudio-19-%235C2D91?logo=visualstudio">
+</div>
+<div>
+    <img alt="platform" src="https://img.shields.io/badge/platform-Windows%2064bit-%230078D6?logo=windows">
+</div>
+<div>
+    <img alt="license" src="https://img.shields.io/github/license/MistEO/MeoAssistance-Arknights">
+    <img alt="commit" src="https://img.shields.io/github/commit-activity/m/MistEO/MeoAssistance-Arknights?color=%23ff69b4">
+    <img alt="stars" src="https://img.shields.io/github/stars/MistEO/MeoAssistance-Arknights?style=social">
+</div>
+<br>
+
 A game assistance for Arknights
 
-一款明日方舟的游戏辅助，供PC端安卓模拟器使用，也勉强兼容安卓手机，龟速开发中……
+一款明日方舟的游戏助手，自动刷理智、智能基建换班、公招识别等，一键完成所有日常，全自动长草！！！
 
-![界面截图](images/gui.png)
-![公招截图](images/openRecruit.png)
+纯图像识别，非内存挂，全图形化界面，兼容模拟器和安卓设备，开罐即食，绝赞开发中！✿✿ヽ(°▽°)ノ✿  
+<br>
+
+## 功能介绍
+
+废话不多说，看图！
+
+![界面截图1](images/gui.png)
+![界面截图2](images/settings1.png)
+![界面截图3](images/settings2.png)
 
 ## 下载地址
 
 [稳定版](https://github.com/MistEO/MeoAssistance/releases/latest)  
 [测试版](https://github.com/MistEO/MeoAssistance/releases)
 
-## 功能介绍
+## 模拟器支持
 
-- 自动刷理智
-    - **新功能：支持刷完自动上传[企鹅物流数据统计](https://penguin-stats.cn/)**（测试版）
-    - **新功能：界面支持统计掉落数量**（测试版）
-    - 可设置是否吃完理智药及数量
-    - 可设置是否吃石头及数量
-    - 可设置刷的次数（用来刷剿灭啥的）
-    - 可设置刷完自动关机
-    - 支持剿灭模式
-    - 支持打完升级了的情况
-    - 支持代理失败的情况，会自动放弃本次行动
-    - 支持刷完自动截图
-    - 支持掉线后重连，继续刷上次的图
-    - 支持凌晨4点更新后重连，继续刷上次的图
-- 全自动公开招募
-    - 自动识别当前招募页所有Tags
-    - 自动计算可能出的干员组合并显示
-    - 自动帮你点击最优解Tags
-    - 自动帮你点击时间9小时
-    - 出5、6星干员弹窗提示
-    - 最新版本已支持夏活新增的`煌`、`灰喉`等干员
-    - 不会帮你点击确定按钮！！！请自行检查辅助选择的是否正确，若出现识别错误，遗漏了高星干员，作者概不负责哦__(:з」∠)_
-- 自动访问好友
-    - 访问完了还会贴心的帮你点进信用商店~
-    - 可设置访问完自动买信用商店的材料
-- 其他优势
-    - 所有点击操作，都是点击按钮内随机位置，并模拟泊松分布（按钮偏中间位置点的概率大，越往旁边点到的概率越小）
-    - 刷理智及访问好友的点击操作，支持设置随机延时，没有封号风险~
-    - 模拟器窗口可以被遮挡、可以最小化、甚至可以老板键隐藏！即使全屏看视频、玩游戏，也完全不影响辅助运行
-    - 软件支持自动更新✿✿ヽ(°▽°)ノ✿
-- 支持多款主流模拟器
-- 勉强兼容安卓手机（USB调试、无线调试）
-- 自适应分辨率及屏幕缩放
-- 未来更多功能见[Todo](#Todo)
-
-### 模拟器支持
-
-#### 蓝叠模拟器
+### 蓝叠模拟器
 
 完美支持。需要在模拟器`设置`-`引擎设置`中打开`允许ADB连接`
 
-#### 蓝叠模拟器国际版
+### 蓝叠模拟器国际版
 
 完美支持。需要在模拟器`设定`-`进阶`中打开`Android调试桥`
 
-#### 夜神模拟器
+### 夜神模拟器
 
 完美支持
 
-#### MuMu模拟器
+### MuMu模拟器
+
+完美支持
+
+### 雷电模拟器
+
+勉强支持。雷电总有莫名其妙的问题，可以试试看，不保证能用（
+
+### 逍遥模拟器
 
 支持
 
-#### 雷电模拟器
+### 腾讯手游助手
+
+不支持。新版本的腾讯好像也是自研引擎了，没开放ADB端口；但是测试是能响应Win32 Api的，有需求再做
+
+### MuMu手游助手（星云引擎）  
+
+不支持。星云引擎这个版本不支持adb控制，甚至不响应Win32 Api鼠标消息，无解_(:з」∠)_
+
+### Win11 WSA
+
+不支持，WSA 目前没有实现 AOSP screencap 需要的接口，无法进行截图。等微软支持后会尝试适配
+
+### 蓝叠模拟器Hyper-V版本
 
 支持
 
-#### 逍遥模拟器
+1. 在模拟器`设定`-`进阶`中打开`Android调试桥`
+2. 下载[ADB](https://dl.google.com/android/repository/platform-tools-latest-windows.zip)，将`platform-tools`文件夹解压到`MeoAsstGui.exe`的同级目录
+3. 在软件`设置`-`连接设置`中填写蓝叠安装目录下`bluestacks.conf`文件的完整路径
 
-支持
+### 其他模拟器、安卓手机/平板、自定义设备
 
-#### 腾讯手游助手
+部分支持
 
-不支持，新版本的腾讯好像也是自研引擎了，没开放ADB端口。但是测试是能响应Win32 Api的，有需求再做
-
-#### MuMu手游助手（星云引擎）  
-
-不支持，星云引擎这个版本不支持adb控制，甚至不响应Win32 Api鼠标消息，无解_(:з」∠)_
-
-#### 其他模拟器
-
-若有其他需要，欢迎给我提[ISSUE](https://github.com/MistEO/MeoAssistance/issues)，会根据情况尽量适配~
-
-#### 安卓手机/平板
-
-部分功能支持，正在开发中……  
-需要下载[谷歌官方ADB](https://dl.google.com/android/repository/platform-tools-latest-windows.zip)，将`platform-tools`文件夹解压到`MeoAsstGui.exe`的同级目录
+- 下载[ADB](https://dl.google.com/android/repository/platform-tools-latest-windows.zip)，将`platform-tools`文件夹解压到`MeoAsstGui.exe`的同级目录
+- 进入软件`设置`-`连接设置`，填写自定义地址（需要填写IP+端口，例如`127.0.0.1:5555`）
+- 目前非`16:9`分辨率下，刷理智、访问好友、信用商店、公招识别、领任务等功能已初步可用；基建功能暂不可用，正在进一步适配中。但仍推荐使用16:9分辨率，经过的测试验证最多，也最稳定。
 
 ## 使用说明
 
 ### 基本说明
 
-1. 根据上面模拟器支持情况，进行对应的`ADB`相关操作
+1. 根据上面模拟器支持情况，进行对应的操作
 2. 解压压缩包，到**没有中文或特殊符号**的文件夹路径
-3. 第一次运行辅助，**请使用管理员权限**打开`MeoAsstGui.exe`。运行过一次后，后续不再需要管理员权限（之后的版本会尝试完全去掉管理员权限）
-4. 运行期间，模拟器窗口可以最小化，全屏玩游戏、看视频等，完全不影响
+3. 第一次运行软件，**请使用管理员权限**打开`MeoAsstGui.exe`。运行过一次后，后续不再需要管理员权限
+4. 开始运行后，所有设置均不可再修改
 
 ### 刷理智
 
-1. 明日方舟打开**蓝色开始行动按钮**的界面
-2. 根据你的需要勾选"吃理智药"和"吃石头"
-3. 点击"开始刷理智"，开始后上面的选项也可以随时修改
-4. 刷完了会自动停止的
+- 若游戏处于**蓝色开始按钮**界面，则会刷当前关卡。否则会前往上次作战的关卡！
+- 主界面上的`吃理智`、`吃石头`、`指定次数`三个选项为短路开关，即三个选项中的任一条件达到，均会视为任务完成，停止刷理智。
+    - 举例1：设置`吃理智药`:`999`、`吃石头`:`10`、`指定次数`:`1`。则在刷完**一次**后，由于满足了`指定次数`:`1`的条件，视为任务完成，停止刷理智。
+    - 举例2：不勾选`吃理智药`、不勾选`吃石头`，设置`指定次数`:`100`。则在当前可用理智全部刷完后（可能只刷了几次），由于满足了`不吃理智药`、`不吃石头`的条件，视为任务完成，停止刷理智。
+- 其他优势
+    - 支持刷完自动上传 [企鹅物流数据统计](https://penguin-stats.cn/)
+    - 支持企鹅物流自定义ID
+    - 支持统计掉落数量
+    - 支持剿灭模式
+    - 支持打完升级了的情况
+    - 支持代理失败的情况，会自动放弃本次行动
+    - 支持掉线后重连，继续刷上次的图
+    - 支持凌晨4点更新后重连，继续刷上次的图
+
+### 基建换班
+
+#### 换班策略
+
+自动计算并选择**单设施内的最优解**，支持所有通用类技能和特殊技能组合；支持识别经验书、赤金、原石碎片、芯片，分别使用不同的干员组合！
+
+#### 宿舍入驻心情阈值
+
+识别心情进度条的百分比；心情小于该阈值的干员，不会再去上班，直接进驻宿舍
+
+#### 特殊说明
+
+- 基建换班目前均为单设施最优解，但非跨设施的全局最优解。例如：`巫恋 龙舌兰`、`红云 稀音`等这类单设施内的组合，都是可以正常识别并使用的；`迷迭香`、`红松骑士团`这类多个设施间联动的体系，目前都是不支持的
+- 会客室仅缺一个线索时，会选择对应流派的干员；否则会选择通用干员
+- 会客室暂不支持送出线索，当线索满时可能会处理异常。建议自动换班完成后自己再去看下会客室的情况
+- 控制中枢策略太过复杂，目前只考虑`阿米娅`、`诗怀雅`、`凯尔希`、`彩虹小队`及其他心情+0.05的干员，后续逐步优化
+
+### 信用商店随缘买
+
+从左到右依次买，但不会买`碳`和`家具零件`。有需要的同学可自行修改`resource\tasks.json`中`CreditShop-NotToBuy`.`text`字段，自定义不买的物品。后续版本会尝试开放界面选项
 
 ### 公开招募识别
 
-1. 明日方舟打开公开招募，有Tag选择的界面
-2. 辅助勾选你需要的选项，点击"开始识别"
-3. 请检查识别结果是否正确，自行判断是否确定开始招募
+- 公招识别和自动公招是两个独立的功能！
+- 公招识别需要手动打开有公招Tag选择的界面再使用
 
-再次强调，本辅助仅会帮你选择最优Tags和时间，不会帮你点击确定按钮！！！请自行检查辅助选择的是否正确，若出现识别错误，遗漏了高星干员，作者概不负责哦__(:з」∠)_
+### 其他乱七八糟的说明
 
-### 访问好友
-
-1. 明日方舟处于任意界面均可，会自动帮你点过去
-2. 根据需要勾选`信用商店随缘买`，点击"访问好友"
-3. 达到10次上限，或者所有可访问的好友都访问完了，就会自动停的
-4. 然后会贴心的帮你跳转到信用商店，顺便收了当天信用~
-5. 信用商店随缘买，就是从左到右依次买，但不会买`碳`和`家具零件`
-
-### 不使用模拟器，而是USB连接安卓手机
-
-1. 下载[ADB程序](https://dl.google.com/android/repository/platform-tools-latest-windows.zip)，将`platform-tools`文件夹解压到`MeoAsstGui.exe`的同级目录
-2. 使用USB有线连接安卓手机和电脑
-3. 请在手机`设置`-`开发者选项`中打开`USB调试`、`USB调试（安全设置）`两个选项。具体操作方式不同品牌手机各不相同，请自行百度查询
-4. 请手动修改`resource\config.json`文件中，`options`.`connectType`为`1`。文件保存后请重新打开程序
-5. 当前仅兼容刷理智、公招计算功能，且公招计算暂时无法设置时间
-
-### 不使用模拟器，而是无线连接安卓手机
-
-1. 下载[ADB程序](https://dl.google.com/android/repository/platform-tools-latest-windows.zip)，将`platform-tools`文件夹解压到`MeoAsstGui.exe`的同级目录
-2. 请保证安卓手机和电脑处于同一局域网中
-3. 请在手机`设置`-`开发者选项`中打开`USB调试`、`USB调试（安全设置）`、`无线调试`三个选项。具体操作方式不同品牌手机各不相同，请自行百度查询
-4. 请手动修改`resource\config.json`文件中，`options`.`connectType`为`2`
-5. 请手动修改`resource\config.json`文件中，`options`.`connectRemoteAddress`为无线调试的IP地址和端口号。文件保存后请重新打开程序
-6. 当前仅兼容刷理智、公招计算功能，且公招计算暂时无法设置时间
-
-**警告：`无线调试`是非常危险的选项，若局域网中存在其他攻击性设备或程序，可能导致手机数据泄露或丢失，请勿在公共的WLAN中使用该功能！**
-
-### 设置操作延时
-
-刷理智、访问好友时，每次点击之前，均随机延时一定的时间，降低封号风险  
-该功能默认是关闭的，需要的话请手动打开：请手动修改`resource\config.json`文件中，`options`.`controlDelayRange`字段的值，格式为`[最小延时, 最大延时]`，单位为毫秒，例如想设置3~5秒的随机延时，即设置为`[ 3000, 5000]` 即可。文件保存后请重新打开程序。
-
-![图例](images/controlDelayRange.png)
+- 公招出5、6星会有弹窗提示
+- 主界面上要执行的任务，是可以拖动改变顺序的。同样设置中基建换班的顺序，也是可以拖动改变的
+- 活动关卡掉落识别到的`未知材料`，一般就是活动商店的票据
+- 新的活动关卡刚上线的时候可能无法正常识别，一般一两天内软件会自动OTA更新资源，更新后即可正常识别
+- 所有点击操作，都是点击按钮内随机位置，并模拟泊松分布（按钮偏中间位置点的概率大，越往旁边点到的概率越小）
+- `resource\config.json`中有一些自定义选项，可以尝试根据自己的需要进行修改
+- 底层算法纯C++开发，并设计了多重的缓存技术，最大限度降低CPU和内存占用
+- 软件支持自动更新✿✿ヽ(°▽°)ノ✿ 推荐非杠精的同学使用测试版，一般来说更新快且bug少（什么MIUI (╯‵□′)╯︵┻━┻
+- [反馈问题](https://github.com/MistEO/MeoAssistance-Arknights/issues)最好可以带上目录下的`asst.log`日志文件，并说下使用的模拟器版本，感谢！
 
 ## Todo
 
-- [ ] 彻底去掉管理员权限
-- [x] 支持设置吃理智药数量
-- [x] 信用商店`看着买`功能
-- [x] 支持所有主流模拟器
-- [ ] 基建智能换班功能
-    - [ ] 图形化界面
-    - [x] 干员及精英化识别
-    - [ ] 干员识别准确率提高到100%
+- [x] 任务队列功能
+- [ ] 常用关卡选关
+- [x] 自动收任务功能
+- [x] 基建智能换班功能
+    - [x] 图形化界面
+    - [x] 干员技能识别
+    - [x] 干员识别准确率提高到100%
     - [x] 宿舍心情识别及入驻
     - [x] 制造站、贸易站智能换班
     - [x] 发电站、办公室换班
     - [x] 使用无人机
-    - [ ] 控制中枢智能换班
-    - [ ] 会客室智能换班
-    - [ ] 会客室智能线索交流
+    - [x] 控制中枢智能换班
+    - [x] 会客室智能换班
+    - [x] 会客室智能线索交流
     - [ ] 支持`迷迭香`等复杂基建体系
-    - [ ] `激进换班模式`
+    - [x] `激进换班模式`
     - [ ] 自定义换班（手动修改配置文件）
+    - [ ] 宿舍换班支持加速心情的干员识别
+    - [x] 贸易站无人机支持设置给经验书还是赤金
 - [ ] 使用GPU进行识别的版本
-- [x] 关卡掉落识别
-- [x] 企鹅物流上传
-- [x] 关卡掉落显示到界面上，并统计
+- [x] 企鹅物流汇报，自定义ID
 - [ ] 指定刷某种材料xx个
 - [ ] `config`中部分选项做成图形化界面
-- [x] 图形化界面部分控件状态保存
-- [x] 支持掉线重连，继续刷理智
-- [x] 支持凌晨4点更新后重连，继续刷理智
-- [x] 支持连安卓手机
+- [x] 界面拖动顺序保存
 - [ ] 进一步的异形屏支持
 - [x] 后台自动更新
 - [x] 忽略当前版本更新
 - [ ] 提供log接口，以及界面log
+- [ ] 更换OCR库，提高公开招募识别率
+- [x] 终极目标！全自动长草机！！！
 
 ## 致谢
 
@@ -192,9 +192,11 @@ A game assistance for Arknights
 - 文字识别库：[chineseocr_lite](https://github.com/DayBreak-u/chineseocr_lite.git)
 - 关卡掉落识别：[企鹅物流识别](https://github.com/KumoSiunaus/penguin-stats-recognize-v3)
 - C++ JSON库：[meojson](https://github.com/MistEO/meojson.git)
+- C++ 运算符解析器：[calculator](https://github.com/kimwalisch/calculator)
 - WPF MVVW框架：[Stylet](https://github.com/canton7/Stylet)
 - WPF控件库：[HandyControl](https://github.com/HandyOrg/HandyControl)
 - C# JSON库: [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json)
+- 下载器：[aria2](https://github.com/aria2/aria2)
 
 ### 数据源
 
@@ -207,10 +209,16 @@ A game assistance for Arknights
 - 非常感谢 [tcyh035](https://github.com/tcyh035) 帮忙设计重构图形界面
 - 非常感谢 [GengGode](https://github.com/GengGode) 和 [DbgDebug](https://github.com/DbgDebug) 提供图像算法思路并协助验证
 - 非常感谢 [LoveLoliii](https://github.com/LoveLoliii) 提供公开招募算法及数据、部分功能逻辑思路
+- 感谢 [内卷地狱](https://jq.qq.com/?_wv=1027&k=ypbzXcA2) 的大佬们提供的各种协助支持
+- 感谢 [LmeSzinc](https://github.com/LmeSzinc) 提供的界面样式参考，~~虽然我抄了个四不像orz~~
 - 感谢参与软件测试、提bug的小伙伴们~
-- ~~感谢[B站直播间](https://live.bilibili.com/2808861)的小伙伴们陪我弹幕吹水~~
+- ~~感谢 [B站直播间](https://live.bilibili.com/2808861) 的小伙伴们陪我弹幕吹水~~
 
 ## 广告
 
-[B站直播间](https://live.bilibili.com/2808861)：每晚直播敲代码，近期很长一段时间应该都是在写本辅助软件  
-[QQ群](https://jq.qq.com/?_wv=1027&k=ypbzXcA2)：欢迎加入~
+[B站直播间](https://live.bilibili.com/2808861)：每晚直播敲代码，近期很长一段时间应该都是在写本助手软件  
+[QQ群：内卷地狱](https://jq.qq.com/?_wv=1027&k=ypbzXcA2)：欢迎加入~  
+
+如果觉得软件对你有帮助，帮忙点个Star吧！~（网页最上方右上角的小星星），这就是对我最大的支持了！
+
+PS：作者前端苦手，现在的界面（WPF）基本是现学现卖的，写得很烂，希望有大佬能帮忙提点PR修改修改，感激不尽_(:з」∠)_

include/AsstCaller.h

@@ -13,19 +13,24 @@ extern "C" {
 
     bool MEOAPI AsstCatchDefault(void* p_asst);
     bool MEOAPI AsstCatchEmulator(void* p_asst);
-    bool MEOAPI AsstCatchUSB(void* p_asst);
-    bool MEOAPI AsstCatchRemote(void* p_asst, const char* address);
+    bool MEOAPI AsstCatchCustom(void* p_asst, const char* address);
+    bool MEOAPI AsstCatchFake(void* p_asst);
 
-    bool MEOAPI AsstStartSanity(void* p_asst);
-    bool MEOAPI AsstStartVisit(void* p_asst, bool with_shopping);
-    bool MEOAPI AsstStartProcessTask(void* p_asst, const char* task);
-    bool MEOAPI AsstStartRecruiting(void* p_asst, const int required_level[], int required_len, bool set_time);
-    //bool MEOAPI AsstStartIndertifyOpers(void* p_asst);
-    //bool MEOAPI AsstStartInfrast(void* p_asst);
-    bool MEOAPI AsstStartDebugTask(void* p_asst);
+    bool MEOAPI AsstAppendFight(void* p_asst, int max_mecidine, int max_stone, int max_times);
+    bool MEOAPI AsstAppendAward(void* p_asst);
+    bool MEOAPI AsstAppendVisit(void* p_asst);
+    bool MEOAPI AsstAppendMall(void* p_asst, bool with_shopping);
+    //bool MEOAPI AsstAppendProcessTask(void* p_asst, const char* task);
+    bool MEOAPI AsstAppendInfrast(void* p_asst, int work_mode, const char** order, int order_size, const char* uses_of_drones, double dorm_threshold);
+    bool MEOAPI AsstAppendRecruit(void* p_asst, int max_times, const int required_level[], int required_len, const int confirm_level[], int confirm_len, bool need_refresh);
+    bool MEOAPI AsstAppendDebug(void* p_asst);
 
-    void MEOAPI AsstStop(void* p_asst);
-    bool MEOAPI AsstSetParam(void* p_asst, const char* type, const char* param, const char* value);
+    bool MEOAPI AsstStartRecruitCalc(void* p_asst, const int required_level[], int required_len, bool set_time);
+    bool MEOAPI AsstStart(void* p_asst);
+    bool MEOAPI AsstStop(void* p_asst);
+
+    bool MEOAPI AsstSetPenguinId(void* p_asst, const char* id);
+    //bool MEOAPI AsstSetParam(void* p_asst, const char* type, const char* param, const char* value);
 
     MEOAPI_PORT const char* MEO_CALL AsstGetVersion();
 #ifdef __cplusplus

resource/config.json

@@ -1,25 +1,27 @@
-{
-    "version": "0.7",
+{
+    "version": "0.9",
     "options": {
         "connectType": 0,
-        "connectType_Doc": "连接类型：0-连接电脑上的模拟器，1-连接USB连接的安卓设备，2-连接局域网中的安卓设备。默认0",
-        "connectRemoteAddress": "",
-        "connectRemoteAddress_Doc": "连接局域网中的安卓设备的地址，仅在connectType为2时生效。格式举例：192.168.1.123:5678",
-        "taskDelay": 1000,
-        "taskDelay_Doc": "识别的延迟：越快识别频率越快，但会增加CPU消耗。单位毫秒，默认1000",
+        "connectType_Doc": "连接类型：0-连接电脑上的模拟器；1-连接自定义端口，请手动修改'emulator.Custom'中的相关字段。默认0",
+        "taskDelay": 2000,
+        "taskDelay_Doc": "识别的延迟：越快识别频率越快，但会增加CPU消耗。单位毫秒，默认2000",
         "printWindow": false,
-        "printWindow_Doc": "截图功能：开启后每次结算界面会截图到screenshot目录下。true-开启，false-关闭，默认true",
-        "uploadToPenguin": true,
-        "uploadToPenguin_Doc": "上传企鹅物流https://penguin-stats.cn/：每次到结算界面，是否上传企鹅物流数据统计网站。true-开启，false-关闭，默认true",
-        "penguinApi": "https://penguin-stats.cn/PenguinStats/api/v2/report",
-        "penguinApi_Doc": "企鹅物流汇报接口",
+        "printWindow_Doc": "截图功能：开启后每次结算界面会截图到screenshot目录下。true-开启，false-关闭，默认false",
+        "penguinReport": true,
+        "penguinReport_Doc": "企鹅数据汇报：每次到结算界面，是否汇报掉落数据至企鹅数据 https://penguin-stats.cn/。true-开启，false-关闭，默认true",
+        "penguinReportCmdLine": "curl -H \"Content-Type: application/json\" -d \"[body]\" \"https://penguin-stats.cn/PenguinStats/api/v2/report\" [extra]",
+        "penguinReportCmdLine_Doc": "企鹅数据汇报的命令，想打印详细信息可以尝试添加 -v -i",
         "controlDelayRange": [
             0,
             0
         ],
         "controlDelayRange_Doc": "点击随机延时：每次点击操作会进行随机延时，降低封号风险（好像也没听说过谁被封号的）。格式为 [ 最小延时, 最大延时 ]，单位为毫秒。例如想设置3~5秒延时，即修改为[ 3000, 5000 ]，默认0~0",
         "ocrThreadNumber": 4,
-        "ocrThreadNumber_Doc": "文字识别库OcrLite的线程数量，理论上开的高点识别会快点，但是会更卡。默认4"
+        "ocrThreadNumber_Doc": "文字识别库OcrLite的线程数量，理论上开的高点识别会快点，但是会更卡。默认4",
+        "adbExtraSwipeDist": 50,
+        "adbExtraSwipeDist_Doc": "额外的滑动距离：adb有bug，同样的参数，偶尔会划得非常远。额外做一个短程滑动，把之前的停下来",
+        "adbExtraSwipeDuration": 1000,
+        "adbExtraSwipeDuration_Doc": "额外的滑动持续时间：adb有bug，同样的参数，偶尔会划得非常远。额外做一个短程滑动，把之前的停下来。若小于0，则关闭额外滑动功能"
     },
     "emulator_Doc": "下面的和模拟器窗口捕获逻辑有关，不需要修改",
     "emulator": {
@@ -30,12 +32,15 @@
             },
             "adb": {
                 "path": "[EmulatorPath]Engine\\ProgramFiles\\HD-Adb.exe",
-                "connect": "[Adb] connect 127.0.0.1:5555",
-                "click": "[Adb] -s 127.0.0.1:5555 shell input tap [x] [y]",
-                "swipe": "[Adb] -s 127.0.0.1:5555 shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] -s 127.0.0.1:5555 shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
-                "screencap": "[Adb] -s 127.0.0.1:5555 exec-out screencap -p"
+                "addresses": [ "127.0.0.1:5555" ],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
+                "connect": "[Adb] connect [Address]",
+                "click": "[Adb] -s [Address] shell input tap [x] [y]",
+                "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
+                "display": "[Adb] -s [Address] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
+                "displayFormat": "cur=%dx%d",
+                "screencap": "[Adb] -s [Address] exec-out screencap -p"
             }
         },
         "BlueStacksInternational": {
@@ -45,12 +50,15 @@
             },
             "adb": {
                 "path": "[EmulatorPath]HD-Adb.exe",
-                "connect": "[Adb] connect 127.0.0.1:5555",
-                "click": "[Adb] -s 127.0.0.1:5555 shell input tap [x] [y]",
-                "swipe": "[Adb] -s 127.0.0.1:5555 shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] -s 127.0.0.1:5555 shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
-                "screencap": "[Adb] -s 127.0.0.1:5555 exec-out screencap -p"
+                "addresses": [ "127.0.0.1:5555" ],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
+                "connect": "[Adb] connect [Address]",
+                "click": "[Adb] -s [Address] shell input tap [x] [y]",
+                "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
+                "display": "[Adb] -s [Address] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
+                "displayFormat": "cur=%dx%d",
+                "screencap": "[Adb] -s [Address] exec-out screencap -p"
             }
         },
         "MuMuEmulator": {
@@ -60,27 +68,33 @@
             },
             "adb": {
                 "path": "[EmulatorPath]..\\vmonitor\\bin\\adb_server.exe",
-                "connect": "[Adb] connect 127.0.0.1:7555",
-                "click": "[Adb] -s 127.0.0.1:7555 shell input tap [x] [y]",
-                "swipe": "[Adb] -s 127.0.0.1:7555 shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] -s 127.0.0.1:7555 shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
-                "screencap": "[Adb] -s 127.0.0.1:7555 exec-out screencap -p"
+                "addresses": [ "127.0.0.1:7555" ],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
+                "connect": "[Adb] connect [Address]",
+                "click": "[Adb] -s [Address] shell input tap [x] [y]",
+                "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
+                "display": "[Adb] -s [Address] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
+                "displayFormat": "cur=%dx%d",
+                "screencap": "[Adb] -s [Address] exec-out screencap -p"
             }
         },
         "LDPlayer": {
             "handle": {
                 "class": "LDPlayerMainFrame",
-                "window": "雷电模拟器"
+                "window": ""
             },
             "adb": {
                 "path": "[EmulatorPath]adb.exe",
-                "connect": "[Adb] connect emulator-5554",
-                "click": "[Adb] -s emulator-5554 shell input tap [x] [y]",
-                "swipe": "[Adb] -s emulator-5554 shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] -s emulator-5554 shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
-                "screencap": "[Adb] -s emulator-5554 shell screencap -p"
+                "addresses": [ "127.0.0.1:5555", "emulator-5554" ],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
+                "connect": "[Adb] connect [Address]",
+                "click": "[Adb] -s [Address] shell input tap [x] [y]",
+                "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
+                "display": "[Adb] -s [Address] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
+                "displayFormat": "cur=%dx%d",
+                "screencap": "[Adb] -s [Address] shell screencap -p"
             }
         },
         "Nox": {
@@ -90,12 +104,15 @@
             },
             "adb": {
                 "path": "[EmulatorPath]nox_adb.exe",
-                "connect": "[Adb] connect 127.0.0.1:62001",
-                "click": "[Adb] -s 127.0.0.1:62001 shell input tap [x] [y]",
-                "swipe": "[Adb] -s 127.0.0.1:62001 shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] -s 127.0.0.1:62001 shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
-                "screencap": "[Adb] -s 127.0.0.1:62001 exec-out screencap -p"
+                "addresses": [ "127.0.0.1:62001", "127.0.0.1:59865" ],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
+                "connect": "[Adb] connect [Address]",
+                "click": "[Adb] -s [Address] shell input tap [x] [y]",
+                "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
+                "display": "[Adb] -s [Address] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
+                "displayFormat": "cur=%dx%d",
+                "screencap": "[Adb] -s [Address] exec-out screencap -p"
             }
         },
         "XYAZ": {
@@ -105,46 +122,36 @@
             },
             "adb": {
                 "path": "[EmulatorPath]adb.exe",
-                "connect": "[Adb] connect 127.0.0.1:21503",
-                "click": "[Adb] -s 127.0.0.1:21503 shell input tap [x] [y]",
-                "swipe": "[Adb] -s 127.0.0.1:21503 shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] -s 127.0.0.1:21503 shell dumpsys window displays | grep init=",
-                "displayRegex": "    init=%dx%d",
-                "screencap": "[Adb] -s 127.0.0.1:21503 shell screencap -p"
+                "addresses": [ "127.0.0.1:21503" ],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
+                "connect": "[Adb] connect [Address]",
+                "click": "[Adb] -s [Address] shell input tap [x] [y]",
+                "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
+                "display": "[Adb] -s [Address] shell dumpsys window displays | grep init=",
+                "displayFormat": "    init=%dx%d",
+                "screencap": "[Adb] -s [Address] shell screencap -p"
             }
         },
-        "Remote": {
+        "Custom": {
             "handle": {
-                "class": "Remote Class",
-                "window": "Remote Window",
+                "class": "Custom Class",
+                "window": "Custom Window",
                 "Doc": "这俩不是用来捕获窗口的，是为了兼容现有的捕获模拟器的字段，随手写的，这两个字段实际不会使用到"
             },
             "adb": {
+                "Doc": "1.请将Adb解压到'path'中的路径（或者修改'path'）；2.请修改addresses为指定地址，若不填写，则使用devices自动查找",
                 "path": "[ExecDir]platform-tools\\adb.exe",
+                "addresses": [],
+                "devices": "[Adb] devices",
+                "addressRegex": "(.+)\tdevice",
                 "connect": "[Adb] connect [Address]",
                 "click": "[Adb] -s [Address] shell input tap [x] [y]",
                 "swipe": "[Adb] -s [Address] shell input swipe [x1] [y1] [x2] [y2] [duration]",
                 "display": "[Adb] -s [Address] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
+                "displayFormat": "cur=%dx%d",
                 "screencap": "[Adb] -s [Address] exec-out screencap -p"
             }
-        },
-        "USB": {
-            "handle": {
-                "class": "USB Class",
-                "window": "USB Window",
-                "Doc": "这俩不是用来捕获窗口的，是为了兼容现有的捕获模拟器的字段，随手写的，这两个字段实际不会使用到"
-            },
-            "adb": {
-                "Doc": "USB连接暂时不兼容多设备的情况",
-                "path": "[ExecDir]platform-tools\\adb.exe",
-                "connect": "[Adb] devices",
-                "click": "[Adb] shell input tap [x] [y]",
-                "swipe": "[Adb] shell input swipe [x1] [y1] [x2] [y2] [duration]",
-                "display": "[Adb] shell dumpsys window displays | grep init= | awk ' { print $3 } '",
-                "displayRegex": "cur=%dx%d",
-                "screencap": "[Adb] exec-out screencap -p"
-            }
         }
     }
 }

resource/recruit.json

@@ -1,4 +1,4 @@
-[
+[
     {
         "name": "Lancet-2",
         "type": "医疗",
@@ -1317,5 +1317,49 @@
         "hidden": false,
         "name-en": "Ambriel",
         "new": true
+    },
+    {
+        "name": "阿",
+        "type": "特种",
+        "level": 6,
+        "sex": "男",
+        "tags": [
+            "远程位",
+            "支援",
+            "输出",
+            "高级资深干员"
+        ],
+        "hidden": false,
+        "name-en": "Aak",
+        "new": true
+    },
+    {
+        "name": "吽",
+        "type": "重装",
+        "level": 5,
+        "sex": "男",
+        "tags": [
+            "近战位",
+            "防护",
+            "治疗",
+            "资深干员"
+        ],
+        "hidden": false,
+        "name-en": "Hung",
+        "new": true
+    },
+    {
+        "name": "正义骑士号",
+        "type": "狙击",
+        "level": 1,
+        "sex": "女",
+        "tags": [
+            "远程位",
+            "支援",
+            "支援机械"
+        ],
+        "hidden": false,
+        "name-en": "Unknown",
+        "new": true
     }
 ]