LÖVE

Carotino wrote: ↑Thu Feb 18, 2021 9:57 pm ...
There could be many forces applying to the point: following others points in proximity, avoiding them, running away, looking for something.
I had a whole fish simulation with different roles (predators, prey, leaders, followers...). It was nice because after a while it started having a life of its own. Fishes started to school together (is it a sound verb? English is not my native tongue), then a predator made them fly in all directions, then a small fish found a leader and started following it, or they simply started to flock together, simultaneously following the others and trying to be no too close. All this sort of things.

togFox wrote: ↑Mon Feb 22, 2021 10:43 pm I asked a similar question on avoidance here:

https://love2d.org/forums/viewtopic.php?f=4&t=90297

I love vectors and there is a very simple way to do path avoidance in my open world (no tiles).

Xii wrote: ↑Sat Feb 13, 2021 3:40 pm If the number of entities isn't too high, what you can do is consider the distances and directions (vectors, essentially) towards each and every other entity.

Begin with a vector pointing straight to the goal, or something. Then, loop over all opponents. Subtract from the initial vector the vector towards each opponent, weighted by the inverse square [\b]of the distance to said opponent. Then have the entity move towards the final resulting vector. This creates avoidance behavior in real-time.

togFox wrote: ↑Mon Feb 22, 2021 10:43 pm I asked a similar question on avoidance here:

https://love2d.org/forums/viewtopic.php?f=4&t=90297

I love vectors and there is a very simple way to do path avoidance in my open world (no tiles).

Xii wrote: ↑Sat Feb 13, 2021 3:40 pm If the number of entities isn't too high, what you can do is consider the distances and directions (vectors, essentially) towards each and every other entity.

Begin with a vector pointing straight to the goal, or something. Then, loop over all opponents. Subtract from the initial vector the vector towards each opponent, weighted by the inverse square of the distance to said opponent. Then have the entity move towards the final resulting vector. This creates avoidance behavior in real-time.

Nikki wrote: ↑Tue Feb 23, 2021 5:23 pm https://natureofcode.com/book/chapter-6 ... us-agents/
this book is very nice and free

btw the weighing part is something like this in pseudocode
0.4 * pathfollowing + 0.6 * obstacle avoidance = the force you want to apply this frame

...

Gunroar:Cannon() wrote: ↑Tue Feb 23, 2021 11:03 pm I really want to just find out how to get the inverse square of a distance and then weigh it against intitial subtracted vector.

-- returns the distance between points x1,y1 and x2,y2
function distance(x1, y1, x2, y2)
	return math.sqrt(((x2-x1)^2)+((y2-y1)^2))
end

function inv_sqrt_distance(x1, y1, x2, y2)
	return 1/math.sqrt(((x2-x1)^2)+((y2-y1)^2))
end

vector_one = {x1,y1}
vector_two = {x2,y2}
subtracted_vector = {vector_one[1]-vector_two[1], vector_one[2]-vector_two[2]}

-- returns the direction from point x1,y1 to x2,y2 (in radians)
function direction(x1, y1, x2, y2)
	return math.atan2(y2-y1, x2-x1)
end

-- returns the distance between points x1,y1 and x2,y2
function distance(x1, y1, x2, y2)
	return math.sqrt(((x2-x1)^2)+((y2-y1)^2))
end

-- returns the point located at x,y moved in direction by distance
function transposition(x, y, direction, distance)
	return distance*math.cos(direction)+x, distance*math.sin(direction)+y
end

local dir = direction(actor_x, actor_y, goal_x, goal_y)
local dist = math.min(actor_speed, distance(actor_x, actor_y, goal_x, goal_y))
actor_x, actor_y = transposition(actor_x, actor_y, dir, dist)

local dir = direction(obst_x, obst_y, actor_x, actor_y) -- note we reversed the coordinates.
-- before we got the direction from actor to goal, now we get direction from obstacle to actor
actor_x, actor_y = transposition(actor_x, actor_y, dir, actor_speed)

local dir = direction(obst_x, obst_y, actor_x, actor_y)
local dist = 1/math.sqrt(distance(obst_x, obst_y, actor_x, actor_y)) * obst_radius
local speed = math.max(actor_speed, dist)
actor_x, actor_y = transposition(actor_x, actor_y, dir, speed)

local goal_dir = direction(actor_x, actor_y, goal_x, goal_y)
local goal_dist = math.min(actor_speed, distance(actor_x, actor_y, goal_x, goal_y))

local avoid_dir = direction(obst_x, obst_y, actor_x, actor_y)
local avoid_dist = 1/math.sqrt(distance(obst_x, obst_y, actor_x, actor_y)) * obst_radius
local avoid_speed = math.max(actor_speed, avoid_dist)

local vector_x, vector_y = transposition(actor_x, actor_y, goal_dir, goal_dist) --towards goal
vector_x, vector_y = transposition(vector_x, vector_y, avoid_dir, avoid_speed) --away from obstacle

local dir = direction(actor_x, actor_y, vector_x, vector_y)
local dist = distance(actor_x, actor_y, vector_x, vector_y)
-- finally move the actor:
actor_x, actor_y = transposition(actor_x, actor_y, dir, math.min(dist, actor_speed))

Xii wrote: ↑Wed Feb 24, 2021 6:59 pm ... Xii wrote a bunch of stuff, actually...