raycaster/goap.hpp

#pragma once
#include <vector>
#include "matrix.hpp"
#include <bitset>
#include <limits>
#include <optional>

namespace ailol {
  constexpr const int SCORE_MAX = std::numeric_limits<int>::max();
  constexpr const size_t STATE_MAX = 93;

  using GOAPState = std::bitset<STATE_MAX>;

  const GOAPState ALL_ZERO;
  const GOAPState ALL_ONES = ~ALL_ZERO;

  struct Action {
    std::string name;
    int cost = 0;

    GOAPState positive_preconds;
    GOAPState negative_preconds;

    GOAPState positive_effects;
    GOAPState negative_effects;

    Action(std::string name, int cost) :
      name(name), cost(cost) { }

    void set_precond(int name, bool val) {
      if(val) {
        positive_preconds[name] = true;
      } else {
        negative_preconds[name] = true;
      }
    }

    void set_effect(int name, bool val) {
      if(val) {
        positive_effects[name] = true;
      } else {
        negative_effects[name] = true;
      }
    }

    bool can_effect(GOAPState& state);
    GOAPState apply_effect(GOAPState& state);

    bool operator==(const Action& other) const {
      return other.name == name;
    }
  };

  using AStarPath = std::deque<Action>;

  const Action FINAL_ACTION("END", SCORE_MAX);

  struct ActionState {
    Action action;
    GOAPState state;

    ActionState(Action action, GOAPState state) :
      action(action), state(state) {}

    bool operator==(const ActionState& other) const {
      return other.action == action && other.state == state;
    }
  };

  bool is_subset(GOAPState& source, GOAPState& target);

  int distance_to_goal(GOAPState& from, GOAPState& to);

  std::optional<AStarPath> plan_actions(std::vector<Action>& actions, GOAPState& start, GOAPState& goal);
}

template<> struct std::hash<ailol::Action> {
  size_t operator()(const ailol::Action& p) const {
    return std::hash<std::string>{}(p.name);
  }
};

template<> struct std::hash<ailol::ActionState> {
  size_t operator()(const ailol::ActionState& p) const {
    return std::hash<ailol::Action>{}(p.action) ^ std::hash<ailol::GOAPState>{}(p.state);
  }
};