refactor: update AStarSearchNode structure and cost calculations

Author: himanusia

src/search/astar/astar.cpp

@@ -12,43 +12,30 @@ vector<AStarSearchNode> astar::generate_successors_astar(const AStarSearchNode&
         for (int direction = -1; direction <= 1; direction += 2) {
             for (int steps = 1; ; ++steps) {
                 vector<Piece> next_pieces_state = current_pieces;
-                Piece& piece_moved_in_state = next_pieces_state[piece_idx]; // ambil referensi ke piece yang akan digerakkan di state baru
+                Piece& piece_moved_in_state = next_pieces_state[piece_idx];
                 bool move_possible = true;
-
-                Coordinates original_coords_of_moving_piece = piece_to_move.coordinates; // simpan koordinat asli sebelum modifikasi
+                Coordinates original_coords_of_moving_piece = piece_to_move.coordinates;
 
                 if (piece_to_move.is_vertical) {
                     for (int s = 1; s <= steps; ++s) {
                         int y_check;
-                        if (direction > 0) {
-                            y_check = piece_to_move.coordinates.y + piece_to_move.size - 1 + s;
-                        } else {
-                            y_check = piece_to_move.coordinates.y - s;
-                        }
+                        if (direction > 0) { y_check = piece_to_move.coordinates.y + piece_to_move.size - 1 + s;}
+                        else { y_check = piece_to_move.coordinates.y - s; }
                         if (!Utils::is_cell_clear(board_node, y_check, piece_to_move.coordinates.x, current_pieces, piece_to_move.id)) {
-                            move_possible = false;
-                            break;
+                            move_possible = false; break;
                         }
                     }
-                    if (move_possible) {
-                        piece_moved_in_state.coordinates.y += (direction * steps);
-                    }
+                    if (move_possible) { piece_moved_in_state.coordinates.y += (direction * steps); }
                 } else {
                     for (int s = 1; s <= steps; ++s) {
                         int x_check;
-                        if (direction > 0) {
-                            x_check = piece_to_move.coordinates.x + piece_to_move.size - 1 + s;
-                        } else {
-                            x_check = piece_to_move.coordinates.x - s;
-                        }
+                        if (direction > 0) { x_check = piece_to_move.coordinates.x + piece_to_move.size - 1 + s; }
+                        else { x_check = piece_to_move.coordinates.x - s; }
                         if (!Utils::is_cell_clear(board_node, piece_to_move.coordinates.y, x_check, current_pieces, piece_to_move.id)) {
-                            move_possible = false;
-                            break;
+                            move_possible = false; break;
                         }
                     }
-                    if (move_possible) {
-                        piece_moved_in_state.coordinates.x += (direction * steps);
-                    }
+                    if (move_possible) { piece_moved_in_state.coordinates.x += (direction * steps); }
                 }
 
                 if (!move_possible) {
@@ -57,11 +44,11 @@ vector<AStarSearchNode> astar::generate_successors_astar(const AStarSearchNode&
 
                 vector<PieceMove> next_path = current_astar_node.path;
                 PieceMove current_pm;
-                current_pm.old_coordinates = original_coords_of_moving_piece; // gunakan koordinat asli
-                current_pm.new_coordinates = piece_moved_in_state.coordinates; // koordinat baru setelah bergerak
+                current_pm.old_coordinates = original_coords_of_moving_piece;
+                current_pm.new_coordinates = piece_moved_in_state.coordinates;
                 next_path.push_back(current_pm);
 
-                int g_cost_successor = current_astar_node.g_cost + COST_PER_MOVE; // biaya pergerakan umumnya 1
+                int g_cost_successor = current_astar_node.actual_g_cost + COST_PER_MOVE;
                 int h_cost_successor = Utils::calculate(board_node, next_pieces_state);
 
                 successors.emplace_back(next_pieces_state, board_node, next_path, g_cost_successor, h_cost_successor, piece_to_move.id, original_coords_of_moving_piece);
@@ -71,25 +58,25 @@ vector<AStarSearchNode> astar::generate_successors_astar(const AStarSearchNode&
     return successors;
 }
 
-
 Solution astar::search_astar(const Board& initial_board, const vector<Piece>& initial_pieces) {
     auto time_start = chrono::high_resolution_clock::now();
     Solution result;
     result.is_solved = false;
     result.node = 0;
 
-    const int COST_PER_MOVE = 1; // biaya setiap gerakan adalah 1
+    const int COST_PER_MOVE = 1;
 
     priority_queue<AStarSearchNode, vector<AStarSearchNode>, greater<AStarSearchNode>> pq;
     set<string> visited_states;
 
-    // node awal
     int initial_g_cost = 0;
     int initial_h_cost = Utils::calculate(initial_board, initial_pieces);
     AStarSearchNode initial_astar_node(initial_pieces, initial_board, {}, initial_g_cost, initial_h_cost);
     pq.push(initial_astar_node);
 
-    UtilityFunctions::print("ASTAR: Initial g_cost: 0, h_cost: " + godot::String::num_int64(initial_h_cost) + ", f_cost: " + godot::String::num_int64(initial_astar_node.f_cost));
+    godot::UtilityFunctions::print("ASTAR: Initial g_cost: " + godot::String::num_int64(initial_astar_node.actual_g_cost) +
+                                   ", h_cost: " + godot::String::num_int64(initial_astar_node.h_cost) +
+                                   ", f_cost: " + godot::String::num_int64(initial_astar_node.val)); // val dari base class adalah f_cost
 
     while (!pq.empty()) {
         AStarSearchNode current_node = pq.top();
@@ -102,29 +89,32 @@ Solution astar::search_astar(const Board& initial_board, const vector<Piece>& in
         }
         visited_states.insert(current_state_str);
 
-        UtilityFunctions::print("ASTAR: Exploring node. " +
-                                       godot::String("f(n):") + godot::String::num_int64(current_node.f_cost) +
-                                       godot::String(", g(n):") + godot::String::num_int64(current_node.g_cost) +
+        godot::UtilityFunctions::print("ASTAR: Exploring node. " +
+                                       godot::String("f(n):") + godot::String::num_int64(current_node.val) + // f_cost dari base.val
+                                       godot::String(", g(n):") + godot::String::num_int64(current_node.actual_g_cost) +
                                        godot::String(", h(n):") + godot::String::num_int64(current_node.h_cost) +
-                                       ". Path length: " + godot::String::num_int64(static_cast<int64_t>(current_node.path.size())));
+                                       ". Path length: " + godot::String::num_int64(static_cast<int64_t>(current_node.path.size()))); // path dari base
 
-        if (current_node.piece_moved != ' ') {
+        if (current_node.piece_moved != ' ') { // piece_moved dari base
             Coordinates new_pos_for_log = {-1, -1};
-            // cari piece yang digerakkan di state saat ini untuk mendapatkan posisi barunya
-            for(const auto& p_state : current_node.pieces) {
+            for(const auto& p_state : current_node.pieces) { // pieces dari base
                 if (p_state.id == current_node.piece_moved) {
                     new_pos_for_log = p_state.coordinates;
                     break;
                 }
             }
-            UtilityFunctions::print("Moved piece: ", godot::String::utf8(&current_node.piece_moved, 1), " from (", current_node.original_position.x, ",", current_node.original_position.y, ") to (", new_pos_for_log.x, ",", new_pos_for_log.y, ")");
+            godot::UtilityFunctions::print("Moved piece: ", godot::String::utf8(&current_node.piece_moved, 1), 
+                                            " from (", current_node.original_position.x, ",", current_node.original_position.y, 
+                                            ") to (", new_pos_for_log.x, ",", new_pos_for_log.y, ")"); // original_position dari base
         }
 
-
-        if (Utils::is_exit(current_node.board, current_node.pieces)) {
+        if (Utils::is_exit(current_node.board, current_node.pieces)) { // board dan pieces dari base
             result.is_solved = true;
-            result.moves = current_node.path;
-            UtilityFunctions::print("ASTAR: Solution Found! Optimal steps (g_cost): " + godot::String::num_int64(current_node.g_cost) + ". Total moves: " + godot::String::num_int64(result.moves.size()) + ". Nodes visited: " + godot::String::num_int64(static_cast<int64_t>(result.node)));
+            result.moves = current_node.path; // path dari base
+            godot::UtilityFunctions::print("ASTAR: Solution Found! Optimal steps (g_cost): " + 
+                                            godot::String::num_int64(current_node.actual_g_cost) + ". Total moves: " + 
+                                            godot::String::num_int64(result.moves.size()) + ". Nodes visited: " + 
+                                            godot::String::num_int64(static_cast<int64_t>(result.node)));
             break;
         }
 
@@ -142,7 +132,7 @@ Solution astar::search_astar(const Board& initial_board, const vector<Piece>& in
     result.duration = chrono::duration<double, milli>(time_end - time_start);
 
     if (!result.is_solved) {
-        UtilityFunctions::print("ASTAR: No solution found. Nodes visited: " + godot::String::num_int64(static_cast<int64_t>(result.node)));
+        godot::UtilityFunctions::print("ASTAR: No solution found. Nodes visited: " + godot::String::num_int64(static_cast<int64_t>(result.node)));
     }
     return result;
 }

src/search/astar/astar.hpp

@@ -9,45 +9,43 @@
 
 #include "../../utils/utils.hpp"
 
-struct AStarSearchNode {
-    vector<Piece> pieces;
-    Board board;
-    vector<PieceMove> path;
-    int g_cost;
+struct AStarSearchNode : public SearchNode {
     int h_cost;
-    int f_cost;
+    int actual_g_cost;
+
+    AStarSearchNode(const std::vector<Piece>& p,
+                    const Board& b,
+                    const std::vector<PieceMove>& path_taken,
+                    int g,
+                    int h,
+                    char pid_moved = ' ',
+                    Coordinates opos_moved = {-1,-1})
+        : SearchNode(p, b, path_taken, g + h, pid_moved, opos_moved),
+          h_cost(h),
+          actual_g_cost(g) {}
 
-    char piece_moved;
-    Coordinates original_position;
-
-    AStarSearchNode(const vector<Piece>& p, const Board& b, const vector<PieceMove>& path, int g, int h, char pid = ' ', Coordinates opos = {-1,-1})
-        : pieces(p), board(b), path(path), g_cost(g), h_cost(h), f_cost(g + h), piece_moved(pid), original_position(opos) {}
-
-    // operator untuk priority queue
     bool operator>(const AStarSearchNode& other) const {
-        if (f_cost != other.f_cost) {
-            return f_cost > other.f_cost;
+        if (this->val != other.val) {
+            return this->val > other.val;
         }
-        // jika f_cost sama, bisa menggunakan h_cost sebagai tie-breaker
-        return h_cost > other.h_cost;
+        return this->h_cost > other.h_cost;
     }
 
-    // fungsi untuk mendapatkan representasi string dari state untuk set 'visited'
-    string get_state_string() const {
-        string s = "";
-        vector<Piece> sorted_pieces = pieces;
+    std::string get_state_string() const {
+        std::string s = "";
+        std::vector<Piece> sorted_pieces = this->pieces;
 
-        sort(sorted_pieces.begin(), sorted_pieces.end(), [](const Piece& a, const Piece& b) {
+        std::sort(sorted_pieces.begin(), sorted_pieces.end(), [](const Piece& a, const Piece& b) {
             return a.id < b.id;
         });
 
         for (const auto& piece : sorted_pieces) {
             if (piece.id == 'K') continue;
             s += piece.id;
             s += ':';
-            s += to_string(piece.coordinates.x);
+            s += std::to_string(piece.coordinates.x);
             s += ',';
-            s += to_string(piece.coordinates.y);
+            s += std::to_string(piece.coordinates.y);
             s += (piece.is_vertical ? "V" : "H");
             s += ";";
         }