Merge pull request #160 from 42core-team/debug-data

Author: FreddyMSchubert

bots/hardcore/configs/game.config.json

@@ -42,7 +42,7 @@
 	"units": [
 		{
 			"name": "Warrior", // name, for aesthetic / display purposes only
-			"visualizer_asset_path": "warrior", // folder that the units visuals are picked from
+			"visualizer_asset_path": "warrior", // folder that the units visuals are picked from by visualizer
 			"cost": 150, // amount of gems needed to spawn the unit
 			"hp": 22, // amount of healthpoints the unit spawns with
 			"baseActionCooldown": 3, // base delay between action executions

bots/hardcore/gridmaster/inc/bot.h

@@ -3,13 +3,4 @@
 
 #include "core_lib.h"
 
-t_obj *ft_get_core_own(void);
-t_obj *ft_get_core_opponent(void);
-t_obj *ft_get_deposit_nearest(t_pos pos);
-t_obj *ft_get_gems_nearest(t_pos pos);
-t_obj *ft_get_deposit_gems_nearest(t_pos pos);
-t_obj *ft_get_units_opponent_nearest(t_pos pos);
-t_obj **ft_get_units_own(void);
-t_obj **ft_get_units_opponent(void);
-
 #endif /* BOT_H */

bots/hardcore/gridmaster/src/getters.c

@@ -1,23 +1,24 @@
 #include "bot.h"
 
-#include <stdio.h>
-#include <time.h>
-
 void ft_on_tick(unsigned long tick);
 
 int main(int argc, char **argv)
 {
 	return core_startGame("Gridmaster", argc, argv, ft_on_tick, false);
 }
 
+static bool is_core_opponent(const t_obj *obj)
+{
+	return (obj->type == OBJ_CORE && obj->s_core.team_id != game.my_team_id);
+}
+
 void ft_on_tick(unsigned long tick)
 {
 	(void)tick;
 
 	core_action_createUnit(UNIT_WARRIOR);
 
-	t_obj **units = ft_get_units_own();
-	for (int i = 0; units && units[i]; i++)
-		core_action_pathfind(units[i], ft_get_core_opponent()->pos);
-	free(units);
+	for (int i = 0; game.objects && game.objects[i]; i++)
+		if (game.objects[i]->type == OBJ_UNIT && game.objects[i]->s_unit.team_id == game.my_team_id)
+			core_action_pathfind(game.objects[i], core_get_obj_filter_nearest((t_pos){0, 0}, is_core_opponent)->pos);
 }

bots/hardcore/gridmaster/src/main.c

@@ -3,6 +3,12 @@
 
 #include "core_lib.h"
 
+typedef struct s_path
+{
+	t_pos *steps;
+	size_t length;
+} t_path;
+
 t_obj *ft_get_core_own(void);
 t_obj *ft_get_core_opponent(void);
 t_obj *ft_get_deposit_nearest(t_pos pos);
@@ -12,6 +18,6 @@ t_obj *ft_get_units_opponent_nearest(t_pos pos);
 t_obj **ft_get_units_own(void);
 t_obj **ft_get_units_opponent(void);
 
-t_pos pathfind_next_step_dijkstra(t_pos start, t_pos target);
+t_path pathfind_full_path_dijkstra(t_pos start, t_pos target);
 
 #endif /* BOT_H */

bots/hardcore/my-core-bot/inc/bot.h

@@ -4,7 +4,7 @@ void ft_on_tick(unsigned long tick);
 
 int main(int argc, char **argv)
 {
-	return core_startGame("YOUR TEAM NAME HERE", argc, argv, ft_on_tick, false);
+	return core_startGame("YOUR TEAM NAME HERE", argc, argv, ft_on_tick, true);
 }
 
 // NOT SURE HOW TO GET STARTED?
@@ -28,9 +28,25 @@ void ft_on_tick(unsigned long tick)
 	t_obj **own_team_warriors = core_get_objs_filter(ft_is_own_team_warrior);
 	for (int i = 0; own_team_warriors && own_team_warriors[i]; i++)
 	{
-		core_action_move(own_team_warriors[i],
-						 pathfind_next_step_dijkstra(own_team_warriors[i]->pos, ft_get_core_opponent()->pos));
+		t_path path = pathfind_full_path_dijkstra(own_team_warriors[i]->pos, ft_get_core_opponent()->pos);
+
+		// Add all path steps to debug visualization
+		for (size_t j = 0; j < path.length; j++)
+		{
+			core_debug_addObjectPathStep(own_team_warriors[i], path.steps[j]);
+		}
+
+		// Move to first step if path exists
+		if (path.length > 0)
+		{
+			core_action_move(own_team_warriors[i], path.steps[0]);
+		}
+
+		core_debug_addObjectInfo(own_team_warriors[i], "Moving towards opponent core :D\n");
 		core_action_attack(own_team_warriors[i], ft_get_core_opponent());
+
+		// Clean up
+		free(path.steps);
 	}
 	free(own_team_warriors);
 }

bots/hardcore/my-core-bot/src/main.c

@@ -1,6 +1,6 @@
 #include "bot.h"
 
-// pathfinding is super basic, but you can start using this if you want to
+// pathfinding is a basic dijkstra, but you can start using this if you want to
 
 #include <limits.h>
 #include <stdbool.h>
@@ -31,7 +31,6 @@ static unsigned long movement_cost_at(t_pos pos)
 	}
 }
 
-// ---------- HELPERS ----------
 static inline size_t pos_to_index(t_pos p, unsigned long grid_size)
 {
 	return (size_t)p.y * (size_t)grid_size + (size_t)p.x;
@@ -55,18 +54,47 @@ static inline bool pos_in_bounds(t_pos p, unsigned long grid)
 	return p.x < grid && p.y < grid;
 }
 
-// ---------- MAIN: DIJKSTRA NEXT STEP ----------
+static t_path reconstruct_full_path(size_t *parent, size_t start_idx, size_t goal_idx, unsigned long grid)
+{
+	t_path result = {.steps = NULL, .length = 0};
+
+	// Count path length
+	size_t count = 0;
+	size_t cur = goal_idx;
+	while (cur != start_idx && parent[cur] != (size_t)(-1))
+	{
+		count++;
+		cur = parent[cur];
+	}
+
+	if (count == 0) return result; // was already at target position
+
+	result.steps = malloc(count * sizeof(t_pos));
+	if (!result.steps) return result;
+	result.length = count;
+
+	cur = goal_idx;
+	for (size_t i = count; i > 0; i--)
+	{
+		result.steps[i - 1] = index_to_pos(cur, grid);
+		cur = parent[cur];
+	}
+
+	return result;
+}
+
 // Returns the next step towards target, or start if no path found / invalid input.
-t_pos pathfind_next_step_dijkstra(t_pos start, t_pos target)
+t_path pathfind_full_path_dijkstra(t_pos start, t_pos target)
 {
+	t_path empty_path = {.steps = NULL, .length = 0};
 	const unsigned long grid = game.config.gridSize;
 	const size_t total = (size_t)grid * (size_t)grid;
 
-	if (grid == 0 || !pos_in_bounds(start, grid) || !pos_in_bounds(target, grid)) return start;
+	if (grid == 0 || !pos_in_bounds(start, grid) || !pos_in_bounds(target, grid)) return empty_path;
 
-	if (start.x == target.x && start.y == target.y) return start;
+	if (start.x == target.x && start.y == target.y) return empty_path;
 
-	// Setup
+	// setup arrays
 	unsigned long *distance = malloc(total * sizeof(unsigned long));
 	bool *visited = malloc(total * sizeof(bool));
 	size_t *parent = malloc(total * sizeof(size_t));
@@ -75,9 +103,8 @@ t_pos pathfind_next_step_dijkstra(t_pos start, t_pos target)
 		free(distance);
 		free(visited);
 		free(parent);
-		return start;
+		return empty_path;
 	}
-
 	for (size_t i = 0; i < total; ++i)
 	{
 		distance[i] = ULONG_MAX;
@@ -87,10 +114,9 @@ t_pos pathfind_next_step_dijkstra(t_pos start, t_pos target)
 
 	const size_t start_idx = pos_to_index(start, grid);
 	const size_t target_idx = pos_to_index(target, grid);
-
 	distance[start_idx] = 0;
 
-	// Dijkstra (naive scan for smallest distance)
+	// Dijkstra algorithm
 	while (true)
 	{
 		size_t current = (size_t)(-1);
@@ -130,8 +156,7 @@ t_pos pathfind_next_step_dijkstra(t_pos start, t_pos target)
 		}
 	}
 
-	// Decide which goal to reconstruct to:
-	// Prefer the real target; if unreachable, choose the best adjacent tile to the target.
+	// Determine goal (prefer target, fallback to adjacent if unreachable)
 	size_t goal_idx = target_idx;
 
 	if (distance[target_idx] == ULONG_MAX)
@@ -151,35 +176,21 @@ t_pos pathfind_next_step_dijkstra(t_pos start, t_pos target)
 			t_pos adj = {.x = (unsigned short)nx, .y = (unsigned short)ny};
 			size_t adj_idx = pos_to_index(adj, grid);
 
-			// Only consider reachable tiles (distance != inf)
 			if (distance[adj_idx] != ULONG_MAX && distance[adj_idx] < best)
 			{
 				best = distance[adj_idx];
 				best_idx = adj_idx;
 			}
 		}
 
-		if (best_idx != (size_t)(-1)) goal_idx = best_idx; // walk next to target
+		if (best_idx != (size_t)(-1)) goal_idx = best_idx;
 	}
 
-	// Reconstruct ONE step from start -> goal_idx
-	t_pos next_step = start;
-	if (distance[goal_idx] != ULONG_MAX)
-	{
-		size_t cur = goal_idx;
-		size_t prev = (size_t)(-1);
-
-		while (cur != start_idx && parent[cur] != (size_t)(-1))
-		{
-			prev = cur;
-			cur = parent[cur];
-		}
-
-		if (cur == start_idx && prev != (size_t)(-1)) next_step = index_to_pos(prev, grid);
-	}
+	// Reconstruct full path
+	t_path result = reconstruct_full_path(parent, start_idx, goal_idx, grid);
 
 	free(distance);
 	free(visited);
 	free(parent);
-	return next_step;
+	return result;
 }