ai.cpp now has a nice easy to use API for loading and running the GOAP things.

tests/ai.cpp

@@ -0,0 +1,220 @@
+#include <catch2/catch_test_macros.hpp>
+#include "dbc.hpp"
+#include "ai.hpp"
+#include <iostream>
+
+using namespace dbc;
+using namespace nlohmann;
+
+TEST_CASE("worldstate works", "[ai]") {
+  enum StateNames {
+    ENEMY_IN_RANGE,
+    ENEMY_DEAD
+  };
+
+  ai::State goal;
+  ai::State start;
+  std::vector<ai::Action> actions;
+
+  // start off enemy not dead and not in range
+  start[ENEMY_DEAD] = false;
+  start[ENEMY_IN_RANGE] = false;
+
+  // end goal is enemy is dead
+  goal[ENEMY_DEAD] = true;
+
+  ai::Action move_closer("move_closer", 10);
+  move_closer.needs(ENEMY_IN_RANGE, false);
+  move_closer.effect(ENEMY_IN_RANGE, true);
+
+  REQUIRE(move_closer.can_effect(start));
+  auto after_move_state = move_closer.apply_effect(start);
+  REQUIRE(start[ENEMY_IN_RANGE] == false);
+  REQUIRE(after_move_state[ENEMY_IN_RANGE] == true);
+  REQUIRE(after_move_state[ENEMY_DEAD] == false);
+  // start is clean but after move is dirty
+  REQUIRE(move_closer.can_effect(start));
+  REQUIRE(!move_closer.can_effect(after_move_state));
+  REQUIRE(ai::distance_to_goal(start, after_move_state) == 1);
+
+  ai::Action kill_it("kill_it", 10);
+  kill_it.needs(ENEMY_IN_RANGE, true);
+  kill_it.needs(ENEMY_DEAD, false);
+  kill_it.effect(ENEMY_DEAD, true);
+
+  REQUIRE(!kill_it.can_effect(start));
+  REQUIRE(kill_it.can_effect(after_move_state));
+
+  auto after_kill_state = kill_it.apply_effect(after_move_state);
+  REQUIRE(!kill_it.can_effect(after_kill_state));
+  REQUIRE(ai::distance_to_goal(after_move_state, after_kill_state) == 1);
+
+  actions.push_back(kill_it);
+  actions.push_back(move_closer);
+
+  REQUIRE(start != goal);
+}
+
+TEST_CASE("basic feature tests", "[ai]") {
+  enum StateNames {
+    ENEMY_IN_RANGE,
+    ENEMY_DEAD
+  };
+
+  ai::State goal;
+  ai::State start;
+  std::vector<ai::Action> actions;
+
+  // start off enemy not dead and not in range
+  start[ENEMY_DEAD] = false;
+  start[ENEMY_IN_RANGE] = false;
+
+  // end goal is enemy is dead
+  goal[ENEMY_DEAD] = true;
+
+  ai::Action move_closer("move_closer", 10);
+  move_closer.needs(ENEMY_IN_RANGE, false);
+  move_closer.effect(ENEMY_IN_RANGE, true);
+
+  ai::Action kill_it("kill_it", 10);
+  kill_it.needs(ENEMY_IN_RANGE, true);
+  // this is duplicated on purpose to confirm that setting
+  // a positive then a negative properly cancels out
+  kill_it.needs(ENEMY_DEAD, true);
+  kill_it.needs(ENEMY_DEAD, false);
+
+  // same thing with effects
+  kill_it.effect(ENEMY_DEAD, false);
+  kill_it.effect(ENEMY_DEAD, true);
+
+  // order seems to matter which is wrong
+  actions.push_back(kill_it);
+  actions.push_back(move_closer);
+
+  auto result = ai::plan_actions(actions, start, goal);
+  REQUIRE(result != std::nullopt);
+
+  auto state = start;
+
+  for(auto& action : *result) {
+    state = action.apply_effect(state);
+  }
+
+  REQUIRE(state[ENEMY_DEAD]);
+}
+
+TEST_CASE("wargame test from cppAI", "[ai]") {
+  std::vector<ai::Action> actions;
+  auto profile = R"({
+    "target_acquired": 0,
+    "target_lost": 1,
+    "target_in_warhead_range": 2,
+    "target_dead": 3
+  })"_json;
+
+  // Now establish all the possible actions for the action pool
+  // In this example we're providing the AI some different FPS actions
+  auto config = R"({
+    "name": "searchSpiral",
+    "cost": 5,
+    "needs": {
+      "target_acquired": false,
+      "target_lost": true
+    },
+    "effects": {
+      "target_acquired": true
+    }
+  })"_json;
+  auto spiral = ai::config_action(profile, config);
+  actions.push_back(spiral);
+
+  config = R"({
+    "name": "searchSerpentine",
+    "cost": 5,
+    "needs": {
+      "target_acquired": false,
+      "target_lost": false
+    },
+    "effects": {
+      "target_acquired": true
+    }
+  })"_json;
+  auto serpentine = ai::config_action(profile, config);
+  actions.push_back(serpentine);
+
+  config = R"({
+    "name": "interceptTarget",
+    "cost": 5,
+    "needs": {
+      "target_acquired": true,
+      "target_dead": false
+    },
+    "effects": {
+      "target_in_warhead_range": true
+    }
+  })"_json;
+  auto intercept = ai::config_action(profile, config);
+  actions.push_back(intercept);
+
+  config = R"({
+    "name": "detonateNearTarget",
+    "cost": 5,
+    "needs": {
+      "target_in_warhead_range": true,
+      "target_acquired": true,
+      "target_dead": false
+    },
+    "effects": {
+      "target_dead": true
+    }
+  })"_json;
+
+  auto detonateNearTarget = ai::config_action(profile, config);
+  actions.push_back(detonateNearTarget);
+
+  // Here's the initial state...
+  config = R"({
+    "target_acquired": false,
+    "target_lost": true,
+    "target_in_warhead_range": false,
+    "target_dead": false
+  })"_json;
+  auto initial_state = ai::config_state(profile, config);
+
+  // ...and the goal state
+  config = R"({
+    "target_dead": true
+  })"_json;
+  auto goal_target_dead = ai::config_state(profile, config);
+
+  auto result = ai::plan_actions(actions, initial_state, goal_target_dead);
+  REQUIRE(result != std::nullopt);
+
+  auto state = initial_state;
+
+  for(auto& action : *result) {
+    fmt::println("ACTION: {}", action.$name);
+    state = action.apply_effect(state);
+  }
+
+  REQUIRE(state[profile["target_dead"]]);
+}
+
+TEST_CASE("ai as a module like sound/sprites", "[ai]") {
+  ai::init();
+
+  auto start = ai::load_state("test_start");
+  auto goal = ai::load_state("test_goal");
+
+  auto script = ai::plan("test1", start, goal);
+  REQUIRE(script != std::nullopt);
+
+  auto state = start;
+  for(auto& action : *script) {
+    fmt::println("ACTION: {}", action.$name);
+    state = action.apply_effect(state);
+  }
+
+  REQUIRE(state[ai::state_id("target_dead")]);
+
+}