ROGUE-like: Bresenham algorithm - godot

Question

I was studying a Mizizizi project and it doesn't even have a function implemented that I found very valuable (which is the Bresenham algorithm). The code and video of the game he developed are accessible via GitHub.
In the code there is a commented function, which I believe draws the lines (circles) that are shown in the video in order to show how the enemy is orienting himself in relation to the player's movement. In fact, I would like help on how to implement, if possible, counting these circles that are drawn from the enemy to the player.
#func _draw():
# for sp in sight_points:
# draw_circle(sp, 4, Color.red)
My intention is to use this information to calculate whether or not I can hit an enemy in a ranged attack action.

Answer 1

Searching for sight_points in the linked repository takes me to Enemy.gd, which I proceed to copy below:
extends Node2D
var alerted = false
func alert():
alerted = true
$AnimationPlayer.play("alert")
$AlertSounds.get_child(randi() % $AlertSounds.get_child_count()).play()
var sight_points = []
# line of sight algorithm found here: http://www.roguebasin.com/index.php?title=Bresenham%27s_Line_Algorithm
func has_line_of_sight(start_coord, end_coord, tilemap: TileMap):
var x1 = start_coord[0]
var y1 = start_coord[1]
var x2 = end_coord[0]
var y2 = end_coord[1]
var dx = x2 - x1
var dy = y2 - y1
# Determine how steep the line is
var is_steep = abs(dy) > abs(dx)
var tmp = 0
# Rotate line
if is_steep:
tmp = x1
x1 = y1
y1 = tmp
tmp = x2
x2 = y2
y2 = tmp
# Swap start and end points if necessary and store swap state
var swapped = false
if x1 > x2:
tmp = x1
x1 = x2
x2 = tmp
tmp = y1
y1 = y2
y2 = tmp
swapped = true
# Recalculate differentials
dx = x2 - x1
dy = y2 - y1
# Calculate error
var error = int(dx / 2.0)
var ystep = 1 if y1 < y2 else -1
# Iterate over bounding box generating points between start and end
var y = y1
var points = []
for x in range(x1, x2 + 1):
var coord = [y, x] if is_steep else [x, y]
points.append(coord)
error -= abs(dy)
if error < 0:
y += ystep
error += dx
if swapped:
points.invert()
sight_points = []
for p in points:
sight_points.append(to_local(Vector2.ONE * 8 + tilemap.map_to_world(Vector2(p[0], p[1]))))
#update()
for point in points:
if tilemap.get_cell(point[0], point[1]) >= 0:
return false
return true
#
#func _draw():
# for sp in sight_points:
# draw_circle(sp, 4, Color.red)
func get_grid_path(start_coord, end_coord, astar: AStar2D, astar_points_cache: Dictionary):
#sight_points=[]
#update()
var path = astar.get_point_path(astar_points_cache[str(start_coord)], astar_points_cache[str(end_coord)])
return path
I remind you that the code is under MIT license, by Miziziziz. I'm taking it here study purposes only.
We can see the quoted comment in the code above.
Also know that sight_points is not used outside this file. In fact, outside form the initialization and a commented use in get_grid_path, the sight_points is only used in the method has_line_of_sight.
According to the comment on has_line_of_sight it is based on Bresenham's Line Algorithm (It is not clear to me under which license the code on that page is). Although the page does not have a GDScript version of the algorithm, the Python version seems similar enough to what Miziziziz did (you can see that it has some of the same comments, and variable names), feel free to compare it in more detail.
Now, since your are interested in knowing how many items are there in the sight_points variable, notice that it is initialized as an array sight_points = [], so you can query its size with sight_points.size().
And that leaves us with the problem of where/when to do it.
Searching for has_line_of_sight in the linked repository we find that it is called in Game.gd, which I will partially quote copy below:
for enemy in enemies.values():
var enemy_pos = world_pos_to_map_coord(enemy.global_position)
if !enemy.alerted and enemy.has_line_of_sight(player_pos, enemy_pos, tilemap):
enemy.alert()
The above snipped is from the _process method. Once more, I remind you that the code is under MIT license, by Miziziziz. I'm taking it here study purposes only.
In the code enemies is a dictionary. We are iterating over its values (not its keys), each one being an enemy object (which are objects whose class is the script we saw before).
The code calls has_line_of_sight between the position of the player and the enemy, and depending on the result it will call alert on the enemy. Having another look at Enemy.gd we see that the alert method marks the enemy as alerted and plays some animation and sound.
We will use this as example of how to use has_line_of_sight. Also, if you recall, has_line_of_sight populates sight_points… It is not a great API but we can do this:
var enemy_pos = world_pos_to_map_coord(enemy.global_position)
if enemy.has_line_of_sight(player_pos, enemy_pos, tilemap) and enemy.sight_points.size() < shoot_distance:
# shoot
pass
Where shoot_distance is some variable or constant you would have to declare.
The important thing here is that we access sight_points right after calling has_line_of_sight. However, that might be not necessary after all. If there is a line of sight, the path is a straight line, so the distance between their global positions might be good enough.
We saw that we had an enemies dictionary. Turns out the keys of the dictionary are the positions on the world. So when the code moves an enemy it removes it from the dictionary and adds it back at another key (from the move_character method):
enemies.erase(str(old_coords))
enemies[str(coords)] = character
So, I believe that would be the way to kill an enemy: remove it from the dictionary… And presumably call queue_free on it.
I don't know how you want to pick the enemy to shoot. But, recall you can iterate over them, so if you want - for example - shoot the nearest one, you can do something like this (not tested code):
var nearest_distance := INF
var nearest_coords := null
for enemy in enemies.values():
var enemy_pos = world_pos_to_map_coord(enemy.global_position)
if enemy.has_line_of_sight(player_pos, enemy_pos, tilemap):
var distance := enemy.sight_points.size()
if distance < shoot_distance and distance < nearest_distance:
nearest_distance = distance
nearest_coords = enemy_pos
if nearest_coords != null:
var enemy = enemies[nearest_coords]
enemies.erase(nearest_coords)
enemy.queue_free()
And if you want enemies to shoot the player, then you would use similar checks, but this time call the kill method (again see move_character method for reference).
Finally notice that the moves_left variable controls when it is the turn of the enemies. When if moves_left == 0: the enemies move (I did not copy the relevant code to this answer). So, if shooting should take a move, you can do moves_left -= 1