def flock(self, boids):
alignment = Vector(0, 0)
cohesion = Vector(0, 0)
separation = Vector(0, 0)
total_in_sight = 0
total_in_personal_space = 0
for boid in boids:
if boid is self:
continue
distance = self.position.distance(boid.position)
if distance < self.sight_radius:
alignment += boid.velocity
cohesion += boid.position
total_in_sight += 1
if distance < self.personal_space_radius:
difference = self.position - boid.position
separation += difference / distance**2
total_in_personal_space += 1
alignment = self.align(alignment, total_in_sight)
cohesion = self.cohere(cohesion, total_in_sight)
separation = self.separate(separation, total_in_personal_space)
self.acceleration = self.al_weight * alignment + self.co_weight * cohesion + self.sep_weight * separation
def setup():
global point_a
global point_b
size(600, 360)
background(255)
point_a = Vector(100, 300)
point_b = Vector(400, 100)
def avoid_edges(self):
if 25 >= self.location.x:
self.desired_velocity = Vector(self.max_speed, self.velocity.y)
self.steering_force = self.desired_velocity - self.velocity
self.steering_force.limit(self.max_turning)
self.acceleration += self.steering_force
elif self.location.x >= width - 25:
self.desired_velocity = Vector(-self.max_speed, self.velocity.y)
self.steering_force = self.desired_velocity - self.velocity
self.steering_force.limit(self.max_turning)
self.acceleration += self.steering_force
elif 25 >= self.location.y:
self.desired_velocity = Vector(self.velocity.x, self.max_speed)
self.steering_force = self.desired_velocity - self.velocity
self.steering_force.limit(self.max_turning)
self.acceleration += self.steering_force
elif self.location.y >= height - 25:
self.desired_velocity = Vector(self.velocity.x, -self.max_speed)
self.steering_force = self.desired_velocity - self.velocity
self.steering_force.limit(self.max_turning)
self.acceleration += self.steering_force
def __init__(self, x, y, width, height):
self.position = Vector(x, y)
self.velocity = Vector(*np.random.rand(2) - 0.5) * 10
self.acceleration = Vector(*np.random.rand(2) - 0.5) / 2
self.width = width
self.height = height
self.maxSpeed = 5
self.perseption = 100
def attack(position, velocity, acceleration, current, ship):
attack_direction = Vector(*ship.pos) - Vector(*current.pos)
attack_direction = (attack_direction - Vector(*current.vel)) * MAX_SPEED
position += velocity
velocity += current.acceleration
return position
def apply_drag(self, strength=0.1):
neg_x = self.velocity.x * -1
neg_y = self.velocity.y * -1
drag_vector = Vector(neg_x, neg_y)
drag_vector.normalize()
drag_magnitude = self.velocity.magnitude_sq * strength
drag_force = drag_vector * drag_magnitude
self.apply_force(drag_force)
def __init__(self, x, y, width, height):
self.position = Vector(x,y);
self.velocity = Vector(*np.random.rand(2)-0.5)*10;
self.acceleration = Vector(*np.random.rand(2)-0.5)/2;
self.width = width;
self.height = height;
self.maxSpeed = 5;
self.perseption = 50; # Radius aroind boid
self.movePos = 2; # Used to move boid towards or away from center of mass
def __init__(self, x, y, width, height):
self.position = Vector(x, y)
self.velocity = Vector(*np.random.rand(2))
self.acceleration = Vector(*np.random.rand(2))
self.maxForce = 0.3 # to control the magnitude of cohesion and separation
self.maxSpeed = 15
self.perception = 200 #max distance to scan for other boids
self.width = width
self.height = height
def __init__(self, start_x=width / 2, start_y=height / 2):
self.location = Vector(start_x, start_y)
self.initial_velocity = Vector(random_gaussian(2, 3), random_gaussian(2, 3))
self.mass = 15
self.acceleration = Vector(0.01, 0.01)
self.desired_velocity = Vector(0, 0)
self.max_speed = random_gaussian(0.1, 0.05)
self.max_turning = 0.5
self.velocity = copy.copy(self.initial_velocity)
self.debug = True
def __init__(self, x, y, dna: DNA = None):
self.pos = Vector(x, y)
self.vel = Vector(0, -2)
self.acc = Vector(0, 0)
self.rad = 10
self.__name = [
names.get_first_name(),
names.get_last_name(),
names.get_last_name()
]
self.__dna = dna
self.__total_evolvers += 1
def __init__(self, x, y, width, height):
self.max_steer = 1
self.max_speed = 5
self.sight_radius = 100
self.personal_space_radius = 50
self.width = width
self.height = height
self.position = Vector(x, y)
self.bucket = self.determine_bucket()
self.velocity = Vector.random_2D() * self.max_speed
self.acceleration = Vector(0, 0)
self.al_weight, self.co_weight, self.sep_weight = ratio((1, 1, 1.1))
def __init__(self, x, y, width, height):
self.position = Vector(x, y)
vec = (np.random.rand(2) - 0.5) * 10
self.velocity = Vector(*vec)
vec = (np.random.rand(2) - 0.5) / 2
self.acceleration = Vector(*vec)
self.max_force = 0.3
self.max_speed = 5
self.perception = 100
self.width = width
self.height = height
def __init__(self,x,y,width,height,size,sight,speeds,force_max,ks): self.id = Boid._id Boid._id += 1 self.width = width self.height = height self.size = size self.sight = sight self.speed_min,self.speed_max = speeds self.force_max = force_max self.ks = ks self.pos = VecTorus(x,y,width,height) self.vel = Vector(*rand_vect(shift=-0.5,scale=self.speed_max)) self.acc = Vector(*rand_vect(shift=-0.5,scale=force_max))
def __init__(self, x, y, width, height):
self.position = Vector(x, y)
self.velocity = Vector(*np.random.rand(2) - 0.5) * 10
self.acceleration = Vector(*np.random.rand(2) - 0.5) / 2
self.width = width
self.height = height
self.maxSpeed = 5
self.perseption = 100
# Radius around boid
self.movePos = 2
# Used to move boid towards or away from center of mass
self.dir = Vector(1, 1)
self.blinkCounter = np.random.randint(9)
def separate(self, vehicles):
sum = Vector(0, 0)
count = 0
for other in vehicles:
d = Vector.distance(self.location, other.location)
repel_vector = other.location - self.location
if d > 0 and d < self.view_range:
sum += repel_vector
count += 1
if count > 0:
sum /= count
steering_force = sum - self.velocity
steering_force.limit(self.max_turning)
self.applyForce(steering_force)
def alignment(self, boids):
steering = Vector(0, 0)
total = 0
average_vector = Vector(0, 0)
for boid in boids:
if np.linalg.norm(boid.position - self.position) < self.perception:
average_vector += boid.velocity
total += 1
if total > 0:
average_vector = Vector(*average_vector / total)
average_vector = (average_vector /
np.linalg.norm(average_vector)) * self.maxSpeed
steering = average_vector - self.velocity
return steering
def draw():
background(250)
global point_a
global point_b
stroke(0)
mouseX = mouse_x
mouseY = mouse_y
mouse = Vector(mouseX, mouseY)
mouse_point = Vector(mouse_x, mouse_y)
line(point_a, mouse)
line(point_a, point_b)
norm = scalar_projection(mouse, point_a, point_b)
ellipse((norm.x, norm.y), 10, 10)
def __init__(self, start_x=width / 2, start_y=height / 2, identifier=0):
self.location = Vector(start_x, start_y)
self.initial_velocity = Vector(random_gaussian(2, 3),
random_gaussian(2, 3))
self.velocity = copy.copy(self.initial_velocity)
self.desired_velocity = Vector(0, 0)
self.acceleration = Vector(0.01, 0.01)
self.max_speed = 1
self.max_turning = 1
self.mass = 5
self.size = 25
self.initial_lifespan = 100
self.lifespan = self.initial_lifespan
self.identifier = identifier
self.is_dead = False
def __init__(self, x, y, width, heigth):
self.position = Vector(x, y)
self.width = width
self.heigth = heigth
self.max_speed = 10
self.max_force = 1
self.perception = 100
#set velocity vector
vec = (np.random.rand(2) - 0.5) * 10
self.velocity = Vector(*vec)
#set acceleration vector
vec = (np.random.rand(2) - 0.5) * 10
self.acceleration = Vector(*vec)
def align(self, boids, p=1):
deviation = Vector(*np.zeros(2))
total = 0
avg_dir = Vector(*np.zeros(2))
#check average direction(by boid.velocity)
for boid in boids:
if np.linalg.norm(boid.position -
self.position) < self.perception * p:
avg_dir += boid.velocity
total += 1
if total > 0:
avg_dir = Vector(*(avg_dir / total))
avg_dir = (avg_dir / np.linalg.norm(avg_dir)) * self.max_speed
deviation = avg_dir - self.velocity
return deviation
def follow(self, path):
# calculate future location
predicted_location = copy.copy(self.velocity)
predicted_location.normalize()
predicted_location *= 10
predicted_location += self.location
shortest_distance = width # initialise to a large number
# check whether future location is on path
for i in range(len(path.points) - 1):
point_a = path.points[i]
point_b = path.points[i + 1]
norm = sp.scalar_projection(predicted_location, point_a, point_b)
if(norm.x < point_a.x or norm.x > point_b.x):
continue
distance = Vector.distance(norm, predicted_location)
if distance < shortest_distance:
shortest_distance = distance
direction = point_b - point_a
direction.normalize()
direction *= 20
target = norm + direction
if shortest_distance > path.radius:
self.steer(target)
if self.debug:
line(self._tup(self.location), (self._tup(predicted_location)))
fill(255, 0, 0)
ellipse((norm.x, norm.y), 10, 10)
fill(0, 255, 0)
ellipse((target.x, target.y), 10, 10)
def update(self):
self.position += self.velocity
self.edges()
self.bucket = self.determine_bucket()
self.velocity += self.acceleration
self.velocity.limit(upper_limit=self.max_speed)
self.acceleration = Vector(0, 0)
def draw():
global fountains
global gravity
global wind
global repeller
background(120)
if mouse_is_pressed:
fountains.append(ParticleSystem(mouse_x, mouse_y, len(fountains)))
print(f"there are {len(fountains)} fountains.")
for fountain in reversed(fountains):
if fountain.is_empty:
print(f"fountain {fountain.identifier} empty")
fountains.remove(fountain)
fountain.update()
fountain.apply_force(gravity)
fountain.apply_repeller(repeller)
repeller.display()
if key_is_pressed:
mouse = Vector(mouse_x, mouse_y)
fountain.apply_force(wind.wind_force(mouse))
wind.display(mouse)
def align(self, boids):
steering = Vector(*np.zeros(2))
total = 0
avg_vector = Vector(*np.zeros(2))
for boid in boids:
if boid.dead == False:
if np.linalg.norm(boid.position - self.position) < self.perception:
avg_vector += boid.velocity
total += 1
if total > 0:
avg_vector /= total
avg_vector = Vector(*avg_vector)
avg_vector = (avg_vector / np.linalg.norm(avg_vector)) * self.max_speed
steering = avg_vector - self.velocity
return steering
def populate(self):
self.points = []
self.points.append(self.first_point)
for point in range(self.num_of_paths):
self.points.append(
Vector(((point + 1) * width / self.num_of_paths),
random_uniform(height, 0)))
def update(self):
self.position += self.velocity
self.velocity += self.acceleration
if np.linalg.norm(self.velocity) > self.maxSpeed:
self.velocity = self.velocity / np.linalg.norm(
self.velocity) * self.maxSpeed
self.acceleration = Vector(0, 0)
def react(self,boids): # reactive traits
boids_nearby = self.nearby(boids)
accs = (
self.align(boids_nearby) * self.ks.get('k_align',0),
self.cohere(boids_nearby) * self.ks.get('k_cohere',0),
self.repel(boids_nearby) * self.ks.get('k_repel',0),
)
self.acc += sum(accs,Vector(0,0))
def align(self, vehicles, method="max"):
sum = Vector(0, 0)
count = 0
for other in vehicles:
d = Vector.distance(self.location, other.location)
if d > 0 and d < self.view_range:
sum += other.velocity
count += 1
if count > 0:
sum /= count
if method == "max":
sum.normalize()
sum *= self.max_speed
if method == "average":
pass
steering_force = sum - self.velocity
steering_force.limit(self.max_turning)
self.applyForce(steering_force)
def update(self):
self.position += self.velocity
self.velocity += self.acceleration
#limit
if np.linalg.norm(self.velocity) > self.max_speed:
self.velocity = self.velocity / np.linalg.norm(
self.velocity) * self.max_speed
self.acceleration = Vector(*np.zeros(2))
def display(self, window, debug=False):
gr = Vector(0, 255, 0)
rd = Vector(255, 0, 0)
col = tuple([int(i) for i in rd.lerp(gr, self.health)])
# print(col)
pg.draw.circle(window, col, self._pos, self.radius * 2)
angle = self.vel.angle + pi / 2
pg.transform.rotate(window, angle)
if debug:
dna2 = remap(self.dna[2], (-2, 2), (5, 100))
dna3 = remap(self.dna[3], (-2, 2), (5, 100))
lineg = tuple(self.pos * dna2)
liner = tuple(self.pos * dna3)
pg.draw.aaline(window, tuple(gr), self._pos, (lineg[:2]))
pg.draw.aaline(window, tuple(rd), self._pos, (liner[:2]))