replace UnlockAllAreas and PreventPersistQuestFlags with generalized rewrite map

src/IntegralExpression.hh

@@ -0,0 +1,188 @@
+#pragma once
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "PlayerSubordinates.hh"
+#include "QuestScript.hh"
+#include "StaticGameData.hh"
+#include "TeamIndex.hh"
+
+class IntegralExpression {
+public:
+  struct Env {
+    const QuestFlagsForDifficulty* flags;
+    const PlayerRecordsBB_Challenge* challenge_records;
+    std::shared_ptr<const TeamIndex::Team> team;
+    size_t num_players;
+    uint8_t event;
+    bool v1_present;
+  };
+
+  IntegralExpression(const std::string& text);
+  ~IntegralExpression() = default;
+  inline bool operator==(const IntegralExpression& other) const {
+    return this->root->operator==(*other.root);
+  }
+  inline bool operator!=(const IntegralExpression& other) const {
+    return !this->operator==(other);
+  }
+  inline int64_t evaluate(const Env& env) const {
+    return this->root->evaluate(env);
+  }
+  inline std::string str() const {
+    return this->root->str();
+  }
+
+protected:
+  class Node {
+  public:
+    virtual ~Node() = default;
+    virtual bool operator==(const Node& other) const = 0;
+    inline bool operator!=(const Node& other) const {
+      return !this->operator==(other);
+    }
+    virtual int64_t evaluate(const Env& env) const = 0;
+    virtual std::string str() const = 0;
+
+  protected:
+    Node() = default;
+  };
+
+  class BinaryOperatorNode : public Node {
+  public:
+    enum class Type {
+      LOGICAL_OR = 0,
+      LOGICAL_AND,
+      BITWISE_OR,
+      BITWISE_AND,
+      BITWISE_XOR,
+      LEFT_SHIFT,
+      RIGHT_SHIFT,
+      LESS_THAN,
+      GREATER_THAN,
+      LESS_OR_EQUAL,
+      GREATER_OR_EQUAL,
+      EQUAL,
+      NOT_EQUAL,
+      ADD,
+      SUBTRACT,
+      MULTIPLY,
+      DIVIDE,
+      MODULUS,
+    };
+    BinaryOperatorNode(Type type, std::unique_ptr<const Node>&& left, std::unique_ptr<const Node>&& right);
+    virtual ~BinaryOperatorNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+
+  protected:
+    Type type;
+    std::unique_ptr<const Node> left;
+    std::unique_ptr<const Node> right;
+  };
+
+  class UnaryOperatorNode : public Node {
+  public:
+    enum class Type {
+      LOGICAL_NOT = 0,
+      BITWISE_NOT,
+      NEGATIVE,
+    };
+    UnaryOperatorNode(Type type, std::unique_ptr<const Node>&& sub);
+    virtual ~UnaryOperatorNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+
+  protected:
+    Type type;
+    std::unique_ptr<const Node> sub;
+  };
+
+  class FlagLookupNode : public Node {
+  public:
+    FlagLookupNode(uint16_t flag_index);
+    virtual ~FlagLookupNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+
+  protected:
+    uint16_t flag_index;
+  };
+
+  class ChallengeCompletionLookupNode : public Node {
+  public:
+    ChallengeCompletionLookupNode(Episode episode, uint8_t stage_index);
+    virtual ~ChallengeCompletionLookupNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+
+  protected:
+    Episode episode;
+    uint8_t stage_index;
+  };
+
+  class TeamRewardLookupNode : public Node {
+  public:
+    TeamRewardLookupNode(const std::string& reward_name);
+    virtual ~TeamRewardLookupNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+
+  protected:
+    std::string reward_name;
+  };
+
+  class NumPlayersLookupNode : public Node {
+  public:
+    NumPlayersLookupNode();
+    virtual ~NumPlayersLookupNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+  };
+
+  class EventLookupNode : public Node {
+  public:
+    EventLookupNode();
+    virtual ~EventLookupNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+  };
+
+  class V1PresenceLookupNode : public Node {
+  public:
+    V1PresenceLookupNode();
+    virtual ~V1PresenceLookupNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+  };
+
+  class ConstantNode : public Node {
+  public:
+    ConstantNode(int64_t value);
+    virtual ~ConstantNode() = default;
+    virtual bool operator==(const Node& other) const;
+    virtual int64_t evaluate(const Env& env) const;
+    virtual std::string str() const;
+
+  protected:
+    int64_t value;
+  };
+
+  std::unique_ptr<const Node> parse_expr(std::string_view text);
+
+  std::unique_ptr<const Node> root;
+};