def mutate(self, rate):
for i in range(len(self.gene)):
k = np.random.random()
if k < rate:
angle = np.random.uniform(-3.14, 3.14)
vec = Pvector(np.cos(angle), np.sin(angle))
vec.mult(np.random.uniform(0, self.maxforce))
self.gene[i] = vec
class Repeller:
def __init__(self,x=400,y=400):
self.loc=Pvector(x,y)
self.dir=None
def calculateForce(self,location):
self.dir=Pvector(location.x,location.y)
self.dir.sub(self.loc)
self.dir.mult(150/(self.dir.magnitude()**3))
def display(self):
no_stroke()
fill(0)
ellipse(self.loc.x,self.loc.y,70,70)
def __init__(self, gene=None, lifetime=100):
self.lifetime = lifetime
self.maxforce = 4
if gene == None:
self.gene = []
for _ in range(self.lifetime):
angle = np.random.uniform(-np.pi, np.pi)
vec = Pvector(np.cos(angle), np.sin(angle))
vec.mult(np.random.uniform(0, self.maxforce))
self.gene.append(vec)
else:
self.gene = gene
def generate_target(self):
if self.car.location.x < 0 or self.car.location.x > 800:
self.car.velocity.x *= -1
if self.car.location.y < 0 or self.car.location.y > 800:
self.car.velocity.y *= -1
self.predict = Pvector(self.car.location.x, self.car.location.y)
self.predict.add(self.car.velocity)
theta = uniform(self.car.velocity.heading() - np.pi / 2,
self.car.velocity.heading() + np.pi / 2)
randvec = Pvector(np.cos(theta), np.sin(theta))
randvec.mult(self.radius)
self.predict.add(randvec)
def get_normal(a,b,v):
global points
predict=v.velocity.get()
predict.setMag(50)
predict.add(v.location)
predict.sub(a)
alongpath=Pvector(b.x-a.x,b.y-a.y)
alongpath.norm()
mag=predict.dot(alongpath)
alongpath.mult(mag)
alongpath.add(a)
if points.points[-1].x>points.points[0].x:
if alongpath.x>b.x or alongpath.x<a.x:
alongpath=b.get()
else:
if alongpath.x<b.x or alongpath.x>a.x:
alongpath=b.get()
return alongpath
def seperate(self,others):
sum=Pvector(0,0)
count=0
for v in others:
loc=self.location.get()
loc.sub(v.location)
d=loc.magnitude()
if d>0 and d<50:
loc.mult(1/d)
sum.add(loc)
count=count+1
if count!=0:
sum.mult(1/count)
sum.norm()
sum.mult(self.maxspeed)
sum.sub(self.velocity)
sum.limit(self.maxforce)
return sum
def generate_flowfield(self):
fields=np.empty((self.row,self.column),dtype='object')
if self.type=='random':
for i in range(self.row):
for j in range(self.column):
theta=uniform(0,2)*np.pi
temp=Pvector(np.cos(theta),np.sin(theta))
temp.mult(self.magnitude)
fields[i][j]=temp
elif self.type=='horizontal':
for i in range(self.row):
for j in range(self.column):
theta=0
temp=Pvector(np.cos(theta),np.sin(theta))
temp.mult(self.magnitude)
fields[i][j]=temp
elif self.type=='perlin':
for i in range(self.row):
for j in range(self.column):
theta=pnoise2((i+1)/5,(j+1)/5,octaves=6,persistence=0.5,lacunarity=2.0,repeatx=self.row,repeaty=self.column,base=0)
theta*=(2*np.pi)
temp=Pvector(np.cos(theta),np.sin(theta))
temp.mult(self.magnitude)
fields[i][j]=temp
return fields
class vehicle:
def __init__(self,location=(400,400),velocity=(0,0),acceleration=(0,0),maxspeed=10,maxforce=3,field=None): # add field for field followers
self.location=Pvector(location[0],location[1])
self.velocity=Pvector(velocity[0],velocity[1])
self.acceleration=Pvector(acceleration[0],acceleration[1])
self.maxspeed=maxspeed
self.maxforce=maxforce
self.radius=8
self.field=field
def seek(self,target):
desired=Pvector(target.x,target.y)
desired.sub(self.location)
mag=desired.magnitude()
if mag<100:
setmag=mag*self.maxspeed/100
desired.setMag(setmag)
else:
desired.setMag(self.maxspeed)
desired.sub(self.velocity)
desired.limit(self.maxforce)
return desired
def seperate(self,others):
sum=Pvector(0,0)
count=0
for v in others:
loc=self.location.get()
loc.sub(v.location)
d=loc.magnitude()
if d>0 and d<50:
loc.mult(1/d)
sum.add(loc)
count=count+1
if count!=0:
sum.mult(1/count)
sum.norm()
sum.mult(self.maxspeed)
sum.sub(self.velocity)
sum.limit(self.maxforce)
return sum
def seek_flow(self):
if self.location.x<0:
self.location.x=799
if self.location.x>799:
self.location.x=0
if self.location.y<0:
self.location.y=799
if self.location.y>799:
self.location.y=0
desired=Pvector(self.lookup(self.location).x,self.lookup(self.location).y)
desired.setMag(self.maxspeed)
desired.sub(self.velocity)
desired.limit(self.maxforce)
self.applyForce(desired)
def lookup(self,location):
k=800/self.field.shape[0]
return self.field[m.floor(location.x/k)][m.floor(location.y/k)]
def update(self):
self.velocity.add(self.acceleration)
self.velocity.limit(self.maxspeed)
self.location.add(self.velocity)
self.acceleration.mult(0)
def applyForce(self,force):
self.acceleration.add(force)
def display(self):
theta=self.velocity.heading()+m.pi/2
stroke_weight(1)
stroke(0)
fill(0)
push_matrix()
translate(self.location.x,self.location.y)
rotate(theta)
begin_shape()
vertex(-self.radius,2*self.radius)
vertex(0,-2*self.radius)
vertex(self.radius,2*self.radius)
end_shape(CLOSE)
pop_matrix()