From ff81c78d13b28a56eed5e09d6e4ac64508f46ad3 Mon Sep 17 00:00:00 2001
From: "Zed A. Shaw" <zed.shaw@gmail.com>
Date: Wed, 12 Mar 2025 00:41:40 -0400
Subject: [PATCH] The autowalker now uses the GOAP AI system to walk the map
and do its thing. The code needs a big cleanup, so I might just do a full
rewrite based on what I know now.
---
autowalker.cpp | 125 ++++++++++++++++++++++++++----------------
autowalker.hpp | 3 +-
scratchpad/a_star.cpp | 82 +++++++++++++++++++++++++++
3 files changed, 162 insertions(+), 48 deletions(-)
create mode 100644 scratchpad/a_star.cpp
diff --git a/autowalker.cpp b/autowalker.cpp
index 31b6e9a..cbbc7dd 100644
--- a/autowalker.cpp
+++ b/autowalker.cpp
@@ -1,20 +1,33 @@
#include "autowalker.hpp"
#include "inventory.hpp"
+#include "ai.hpp"
template<typename Comp>
-Pathing compute_paths(gui::FSM& fsm, int& count_out) {
+int number_left(gui::FSM& fsm) {
+ int count = 0;
+
+ fsm.$level.world->query<components::Position, Comp>(
+ [&](const auto ent, auto&, auto&) {
+ if(ent != fsm.$level.player) {
+ count++;
+ }
+ });
+
+ return count;
+}
+
+template<typename Comp>
+Pathing compute_paths(gui::FSM& fsm) {
auto& walls_original = fsm.$level.map->$walls;
auto walls_copy = walls_original;
Pathing paths{matrix::width(walls_copy), matrix::height(walls_copy)};
- count_out = 0;
fsm.$level.world->query<components::Position>(
[&](const auto ent, auto& position) {
if(ent != fsm.$level.player) {
if(fsm.$level.world->has<Comp>(ent)) {
paths.set_target(position.location);
- count_out = count_out + 1;
} else {
// this will mark that spot as a wall so we don't path there temporarily
walls_copy[position.location.y][position.location.x] = WALL_PATH_LIMIT;
@@ -28,17 +41,18 @@ Pathing compute_paths(gui::FSM& fsm, int& count_out) {
}
Pathing Autowalker::path_to_enemies() {
- return compute_paths<components::Combat>(fsm, enemy_count);
+ return compute_paths<components::Combat>(fsm);
}
Pathing Autowalker::path_to_items() {
- return compute_paths<components::InventoryItem>(fsm, item_count);
+ return compute_paths<components::InventoryItem>(fsm);
}
Pathing Autowalker::path_to_devices() {
- return compute_paths<components::Device>(fsm, device_count);
+ return compute_paths<components::Device>(fsm);
}
+
void Autowalker::window_events() {
fsm.$window.handleEvents(
[&](const sf::Event::KeyPressed &) {
@@ -57,9 +71,11 @@ void Autowalker::process_combat() {
|| fsm.in_state(gui::State::ATTACKING))
{
if(fsm.in_state(gui::State::ATTACKING)) {
+ fmt::println("In attacking state, sending a TICK");
send_event(gui::Event::TICK);
} else {
- send_event(gui::Event::ATTACK);
+ fmt::println("Not in ATTACK, sending an ATTACK to continue combat.");
+ send_event(gui::Event::ATTACK);;
}
}
}
@@ -73,12 +89,15 @@ bool Autowalker::path_player(Pathing& paths, Point& target_out) {
bool found = paths.random_walk(target_out, false, PATHING_TOWARD);
if(!found) {
- dbc::log("no neighbor found, aborting autowalk");
+ dbc::log("no neighbor found in any direction, aborting autowalk");
+ matrix::dump("NO TOWARD", paths.$paths, target_out.x, target_out.y);
return false;
}
if(!fsm.$level.map->can_move(target_out)) {
dbc::log("neighbors is telling me to go to a bad spot.");
+ matrix::dump("BAD TARGET PATHS", paths.$paths, target_out.x, target_out.y);
+ matrix::dump("BAD TARGET MAP", fsm.$level.map->walls(), target_out.x, target_out.y);
return false;
}
@@ -156,34 +175,64 @@ void Autowalker::autowalk() {
window_events();
if(!fsm.autowalking) return;
- process_combat();
- auto paths = path_to_enemies();
+ int move_attempts = 0;
- if(enemy_count == 0) {
- dbc::log("Killed everything, now finding items.");
- paths = path_to_items();
- }
+ auto start = ai::load_state("Walker::initial_state");
+ auto goal = ai::load_state("Walker::final_state");
- if(enemy_count == 0 && item_count == 0) {
- dbc::log("No more items, find the exit.");
- paths = path_to_devices();
- }
+ do {
+ int enemy_count = number_left<components::Combat>(fsm);
+ int item_count = number_left<components::InventoryItem>(fsm);
+
+ fmt::println("ENEMY COUNT: {}, ITEM COUNT: {}", enemy_count, item_count);
+
+ window_events();
+ ai::set(start, "no_more_enemies", enemy_count == 0);
+ ai::set(start, "no_more_items", item_count == 0);
+ ai::set(start, "enemy_found",
+ fsm.in_state(gui::State::IN_COMBAT) ||
+ fsm.in_state(gui::State::ATTACKING));
+
+ auto a_plan = ai::plan("Walker::actions", start, goal);
+
+ // need a test for plan complete and only action is END
+ for(auto action : a_plan.script) {
+ if(action.$name == "find_enemy") {
+ // this is where to test if enemy found and update state
+ fmt::println("FINDING AN ENEMY");
+ auto paths = path_to_enemies();
+ auto pos = get_current_position();
+ matrix::dump("FINDING", paths.$paths, pos.x, pos.y);
+ process_move(paths);
+ } else if(action.$name == "kill_enemy") {
+ fmt::println("KILLING ENEMY");
+ process_combat();
+ } else if(action.$name == "find_healing") {
+ fmt::println("FINDING HEALING");
+ auto paths = path_to_items();
+ process_move(paths);
+ // do the path to healing thing
+ } else if(action.$name == "collect_items") {
+ fmt::println("COLLECTING ITEMS");
+ auto paths = path_to_items();
+ process_move(paths);
+ // path to the items and get them all
+ } else if(action.$name == "END") {
+ fmt::println("END STATE, complete? {}", a_plan.complete);
+ fsm.autowalking = false;
+ } else {
+ fmt::println("Unknown action: {}", action.$name);
+ }
- if(enemy_count == 0 &&
- item_count == 0 &&
- device_count == 0)
- {
- fsm.autowalking = false;
- dbc::log("no more enemies, items, or devices.");
- return;
- }
+ move_attempts++;
+ }
+ } while(move_attempts < 100 && fsm.autowalking);
+}
+void Autowalker::process_move(Pathing& paths) {
Point current = get_current_position();
Point target = current;
- show_map_overlay(paths.$paths, current);
-
-
if(!path_player(paths, target)) {
dbc::log("no paths found, aborting autowalk");
fsm.autowalking = false;
@@ -191,28 +240,12 @@ void Autowalker::autowalk() {
}
rotate_player(current, target);
+ while(fsm.in_state(gui::State::ROTATING)) send_event(gui::Event::TICK);
- int move_attempts = 0;
- do {
- process_combat();
- process_move();
- // BUG: sometimes in idle but there's an enemy near but combat hasn't started
- // for now just toss out an ATTACK and it'll be ignored or cause combat
- send_event(gui::Event::ATTACK);
- move_attempts++;
- } while(move_attempts < 100 && !player_has_moved(target));
-}
-
-void Autowalker::process_move() {
send_event(gui::Event::MOVE_FORWARD);
while(fsm.in_state(gui::State::MOVING)) send_event(gui::Event::TICK);
}
-bool Autowalker::player_has_moved(Point target) {
- Point current = get_current_position();
- return current.x == target.x && current.y == target.y;
-}
-
void Autowalker::send_event(gui::Event ev) {
fsm.event(ev);
fsm.render();
diff --git a/autowalker.hpp b/autowalker.hpp
index 7e9b519..aae0381 100644
--- a/autowalker.hpp
+++ b/autowalker.hpp
@@ -19,8 +19,7 @@ struct Autowalker {
bool path_player(Pathing& paths, Point &target_out);
Point get_current_position();
void rotate_player(Point current, Point target);
- bool player_has_moved(Point target);
- void process_move();
+ void process_move(Pathing& paths);
Pathing path_to_enemies();
Pathing path_to_items();
Pathing path_to_devices();
diff --git a/scratchpad/a_star.cpp b/scratchpad/a_star.cpp
new file mode 100644
index 0000000..2052cbb
--- /dev/null
+++ b/scratchpad/a_star.cpp
@@ -0,0 +1,82 @@
+
+constexpr const float SCORE_MAX = std::numeric_limits<float>::max()
+
+using AStarPath = std::deque<Point>;
+
+void update_map(Matrix& map, std::deque<Point>& total_path) {
+ for(auto &point : total_path) {
+ map[point.y][point.x] = 10;
+ }
+}
+
+AStarPath reconstruct_path(std::unordered_map<Point, Point>& came_from, Point current) {
+ std::deque<Point> total_path{current};
+
+ while(came_from.contains(current)) {
+ current = came_from[current];
+ total_path.push_front(current);
+ }
+
+ return total_path;
+}
+
+inline float h(Point from, Point to) {
+ return std::hypot(float(from.x) - float(to.x),
+ float(from.y) - float(to.y));
+}
+
+inline float d(Point current, Point neighbor) {
+ return std::hypot(float(current.x) - float(neighbor.x),
+ float(current.y) - float(neighbor.y));
+}
+
+inline Point find_lowest(std::unordered_map<Point, float>& open_set) {
+ dbc::check(!open_set.empty(), "open set can't be empty in find_lowest");
+ Point result;
+ float lowest_score = SCORE_MAX;
+
+ for(auto [point, score] : open_set) {
+ if(score < lowest_score) {
+ lowest_score = score;
+ result = point;
+ }
+ }
+
+ return result;
+}
+
+
+std::optional<AStarPath> path_to_player(Matrix& map, Point start, Point goal) {
+ std::unordered_map<Point, float> open_set;
+ std::unordered_map<Point, Point> came_from;
+ std::unordered_map<Point, float> g_score;
+ g_score[start] = 0;
+
+ open_set[start] = g_score[start] + h(start, goal);
+
+ while(!open_set.empty()) {
+ auto current = find_lowest(open_set);
+
+ if(current == goal) {
+ return std::make_optional<AStarPath>(reconstruct_path(came_from, current));
+ }
+
+ open_set.erase(current);
+
+ for(matrix::compass it{map, current.x, current.y}; it.next();) {
+ Point neighbor{it.x, it.y};
+
+ float d_score = d(current, neighbor) + map[it.y][it.x] * SCORE_MAX;
+ float tentative_g_score = g_score[current] + d_score;
+ float neighbor_g_score = g_score.contains(neighbor) ? g_score[neighbor] : SCORE_MAX;
+ if(tentative_g_score < neighbor_g_score) {
+ came_from[neighbor] = current;
+ g_score[neighbor] = tentative_g_score;
+ // open_set gets the fScore
+ open_set[neighbor] = tentative_g_score + h(neighbor, goal);
+ }
+ }
+ }
+
+ return std::nullopt;
+}