simple AI

[Drizzel]

I just watched a video of codeBullet yesterday where he explained the basics of coding a simple “intelligent” algorithm that I wanted to recreate. The idea is that the black squares (I don’t know how to make dots) try to find their way to the blue target in the top left corner. Here’s the code of my main script:

from scene import *
import sound
import random
import math
import extension
A = Action

entitiesPerGeneration = 5

class MyScene (Scene):
	def setup(self):
		self.position = self.size/2
		self.background_color = 'white'
		self.target = ShapeNode(rect(0,0,10,10))
		self.target.color = 'blue'
		self.target.size = (10, 10)
		self.target.position = self.size/2-(self.size.x-10,10)
		self.add_child(self.target)
		self.obstacles = []
		self.entities = []
		for entity in range(entitiesPerGeneration):
			self.entities.append(ShapeNode(rect(0,0,10,10)))
			self.entities[entity].color = 'black'
			self.entities[entity].size = (10,10)
			self.entities[entity].position = (0,0)
			self.entities[entity].vel = Vector2(0, 0)
			self.entities[entity].acc = Vector2(0, 0)
			self.entities[entity].moves = []
			self.entities[entity].currentMove = 0
			self.entities[entity].fitness = 0
			self.entities[entity].done = False
			self.add_child(self.entities[entity])
		pass
	
	def did_change_size(self):
		pass
	
	def update(self):
		if extension.allDone(self):
			fitness = extension.calculateFitness(self)
			parent = extension.chooseParent(self)
			extension.killEntities(self)
			for i in range(entitiesPerGeneration-1):
				extension.createEntity(self, parent.moves, parent.vel, parent.acc)
			for entity in self.entities:
				extension.mutate(self, entity)
			extension.createEntity(self, parent.moves, parent.vel, parent.acc)
			self.entities[len(self.entities)-1].color = 'pink'
			
			
		else:
			for entity in self.entities:
				if entity.done == False:
					extension.move(self, entity)
					extension.checkCollision(self, entity)
		
		pass
	
	def touch_began(self, touch):
		pass
	
	def touch_moved(self, touch):
		pass
	
	def touch_ended(self, touch):
		pass

if __name__ == '__main__':
	run(MyScene(), show_fps=False)

and here’s extension.py

from scene import *
import sound
import random
import math
import time

maxVel = 100
accIncrease = 15
mutationPercentage = 5

def calculateDistance(a, b):
	x1 = a[0]  
	x2 = b[0]
	y1 = a[1]
	y2 = b[1]
	dist = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)  
	return dist 

			
def move(self, sprite):
	if sprite.currentMove <= len(sprite.moves)-1:
		sprite.acc = sprite.moves[sprite.currentMove]
		
	else:
		angle = random.randint(0, 360)
		changeX = round(math.sin(math.radians(angle)), 4)
		changeY = round(math.cos(math.radians(angle)), 4)
		sprite.acc = Vector2(changeX, changeY) * accIncrease
		
	sprite.vel += sprite.acc

	if sprite.vel[0] <= -maxVel or sprite.vel[0] >= maxVel:  #checks that velocity won't exceed maxVel
		if sprite.vel[0] < 0: sprite.vel = Vector2(-maxVel, sprite.vel[1])
		else: sprite.vel = Vector2(maxVel, sprite.vel[1])
			
	if sprite.vel[1] <= -maxVel or sprite.vel[1] >= maxVel:
		if sprite.vel[1] < 0: sprite.vel = Vector2(sprite.vel[0], -maxVel)
		else: sprite.vel = Vector2(sprite.vel[0], maxVel)

	sprite.moves.append(sprite.acc)
		
	sprite.currentMove = sprite.currentMove + 1
	sprite.run_action(Action.move_by(sprite.vel[0]*self.dt, sprite.vel[1]*self.dt,self.dt))
	
def allDone(self):
	allDone = True
	for entity in self.entities:
		if entity.done == False:
			allDone = False
			break
	return allDone
	
def calculateFitness(self):
	for entity in self.entities:
		try:
			distance = calculateDistance(entity.position, self.target.position)
			sprite.fitness = 1000/distance
		except: ZeroDivisionError
		

def checkCollision(self, entity):
	if entity.frame.intersects(self.target.frame): 
		entity.done = True
		entity.color = '#00ff00'
	if entity.position.x < -self.size.x/2 + entity.size.x/2 or entity.position.x > self.size.x/2 - entity.size.x/2 or entity.position.y < -self.size.y/2 + entity.size.y/2 or entity.position.y > self.size.y/2 - entity.size.y/2:
		entity.done = True
		entity.color = 'red'
	for obstacle in self.obstacles:
		if entity.frame.intersects(obstacle.frame): 
			entity.done = True
			entity.color = 'red'
			
def chooseParent(self):
	parents = []
	for i in range(len(self.entities)):
		for a in range(round(self.entities[i].fitness)+1):
			parents.append(i)
	parent = random.choice(parents)
	return self.entities[parent]
	
def killEntities(self):
	for sprite in self.entities:
		sprite.remove_from_parent()
	self.entities = []
	
def createEntity(self, moves, vel, acc):
	self.entities.append(ShapeNode(rect(0,0,10,10)))
	self.entities[len(self.entities)-1].color = 'black'
	self.entities[len(self.entities)-1].size = (10,10)
	self.entities[len(self.entities)-1].position = (0,0)
	self.entities[len(self.entities)-1].vel = vel
	self.entities[len(self.entities)-1].acc = acc
	self.entities[len(self.entities)-1].moves = moves
	self.entities[len(self.entities)-1].currentMove = 0
	self.entities[len(self.entities)-1].fitness = 0
	self.entities[len(self.entities)-1].done = False
	self.add_child(self.entities[len(self.entities)-1])
	
def mutate(self, entity):
	for i in range(len(entity.moves)):
		if random.randint(1, 100) <= mutationPercentage:
			
			angle = random.randint(0, 360)
			changeX = round(math.sin(math.radians(angle)), 4)
			changeY = round(math.cos(math.radians(angle)), 4)
			move = Vector2(changeX, changeY) * accIncrease
			entity.moves[i] = move
			print('mutated')

I know it’s not the shortest and most beautiful code out there, but I hope the smart ones here can solve my issue :)

In theory, if the whole generation is dead, a new generation is created from one of the many squares. This new generation then mutates randomly. Therefore all squares have a slightly different path, even though they have the same parent. Somehow the whole generation follows the same path (which didn’t even change from the parent’s path). I tried to set the mutationPercentage to 100, so that 100% of all directions in the path are changed, but nothing changed. And afterwards pythonista crashes, again no idea why :D

[Drizzel]

I changed my code up a bit, so here’s the main script:

from scene import *
import sound
import random
import math
import extension
A = Action
history = []

entitiesPerGeneration = 5

class MyScene (Scene):
	def setup(self):
		self.position = self.size/2
		self.background_color = 'white'
		self.target = ShapeNode(rect(0,0,10,10))
		self.target.color = 'blue'
		self.target.size = (10, 10)
		self.target.position = self.size/2-(self.size.x-10,10)
		self.add_child(self.target)
		self.obstacles = []
		self.entities = []
		for entity in range(entitiesPerGeneration):
			extension.createEntity(self, [])
		pass
	
	def did_change_size(self):
		pass
	
	def update(self):
		if extension.allDone(self):
			fitness = extension.calculateFitness(self)
			parent = extension.chooseParent(self)
			extension.killEntities(self)
			for i in range(entitiesPerGeneration):
				extension.createEntity(self, parent.moves)
				extension.mutate(self, self.entities[i])
				print(self.entities[i].moves, '\n')
			print('------------------------------------------------------------------------\n')
			#entity.moves are different for every entity up to here
			
			for i in range(len(self.entities)-1): #checks if all entities have the same moves
				print(self.entities[i+1].moves == self.entities[i].moves)
				print(self.entities[i].moves)
			
				
		else:
			for entity in self.entities:
				if entity.done == False:
					extension.move(self, entity)
					extension.checkCollision(self, entity)
		pass
	
if __name__ == '__main__':
	run(MyScene(), show_fps=False)

And here’s the extension script:

from scene import *
import sound
import random
import math
import time

maxVel = 200
accIncrease = 15
mutationPercentage = 100

def calculateDistance(a, b):
	x1 = a[0]  
	x2 = b[0]
	y1 = a[1]
	y2 = b[1]
	dist = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)  
	return dist 

			
def move(self, sprite):
	if sprite.currentMove <= len(sprite.moves)-1:
		sprite.acc = sprite.moves[sprite.currentMove]
	else:
		angle = random.randint(0, 360)
		changeX = round(math.sin(math.radians(angle)), 4)
		changeY = round(math.cos(math.radians(angle)), 4)
		sprite.acc = Vector2(changeX, changeY) * accIncrease
		sprite.moves.append(sprite.acc)
		
	sprite.vel += sprite.acc

	if sprite.vel[0] <= -maxVel or sprite.vel[0] >= maxVel:  #checks that velocity won't exceed maxVel
		if sprite.vel[0] < 0: sprite.vel = Vector2(-maxVel, sprite.vel[1])
		else: sprite.vel = Vector2(maxVel, sprite.vel[1])		
	if sprite.vel[1] <= -maxVel or sprite.vel[1] >= maxVel:
		if sprite.vel[1] < 0: sprite.vel = Vector2(sprite.vel[0], -maxVel)
		else: sprite.vel = Vector2(sprite.vel[0], maxVel)

	sprite.currentMove = sprite.currentMove + 1
	sprite.run_action(Action.move_by(sprite.vel[0]*self.dt, sprite.vel[1]*self.dt,self.dt))
	
def allDone(self):
	allDone = True
	for entity in self.entities:
		if entity.done == False:
			allDone = False
			break
	return allDone
	
def calculateFitness(self):
	for entity in self.entities:
		try:
			distance = calculateDistance(entity.position, self.target.position)
			sprite.fitness = 1000/distance
		except: ZeroDivisionError
		

def checkCollision(self, entity):
	if entity.frame.intersects(self.target.frame): 
		entity.done = True
		entity.color = '#00ff00'
	if entity.position.x < -self.size.x/2 + entity.size.x/2 or entity.position.x > self.size.x/2 - entity.size.x/2 or entity.position.y < -self.size.y/2 + entity.size.y/2 or entity.position.y > self.size.y/2 - entity.size.y/2:
		entity.done = True
		entity.color = 'red'
	for obstacle in self.obstacles:
		if entity.frame.intersects(obstacle.frame): 
			entity.done = True
			entity.color = 'red'
			
def chooseParent(self):
	parents = []
	for i in range(len(self.entities)):
		for a in range(round(self.entities[i].fitness)+1):
			parents.append(i)
	parent = random.choice(parents)
	return self.entities[parent]
	
def killEntities(self):
	for sprite in self.entities:
		sprite.remove_from_parent()
	self.entities = []
	
def createEntity(self, moves):
	self.entities.append(ShapeNode(rect(0,0,10,10)))
	self.entities[len(self.entities)-1].color = 'black'
	self.entities[len(self.entities)-1].size = (10,10)
	self.entities[len(self.entities)-1].position = (0,0)
	self.entities[len(self.entities)-1].vel = Vector2(0,0)
	self.entities[len(self.entities)-1].acc = Vector2(0,0)
	self.entities[len(self.entities)-1].moves = moves
	self.entities[len(self.entities)-1].currentMove = 0
	self.entities[len(self.entities)-1].fitness = 0
	self.entities[len(self.entities)-1].done = False
	self.add_child(self.entities[len(self.entities)-1])
	
def mutate(self, entity):
	for i in range(len(entity.moves)):
		if random.randint(1, 100) <= mutationPercentage:
			angle = random.randint(0, 360)
			changeX = round(math.sin(math.radians(angle)), 4)
			changeY = round(math.cos(math.radians(angle)), 4)
			move = Vector2(changeX, changeY) * accIncrease
			entity.moves[i] = move

I really have no idea why this happens,but this happened before. Although the mutate() function does actually change the path of the squares (verified by printing out the path of every square and comparing them manually), all of these paths change to the path of the last entity in the self.entities array. I check this with 3 lines of code just after printing out all of the paths, and somehow they all are the same without some command to do that. There has to be some statement that causes this, but I have absolutely no clue how/ where/ why this occurs.

[JonB]

you have a few problems. The first one is, your calculateFitness runction has an error, which is being hidden because you are using try-except instead of catching a specific exception (i think you misplaced your colon, then forgot what you wanted to do in case of divide by zero)

Next, you have to remember that lists are objects. So

>>> a=[1,2,3]
>>> b=a
>>> b.append(4)
>>> a
[1, 2, 3, 4]

so, when you copy moves to the new entities, you are copying the object, thus mutations all happen on the same copy. assign moves.copy() instead, or [m for m in moves]

finally, I'd suggest you add a shapenode representing the selected parent, so you can see what is happening. Also you might want to label the fitness of each node. your fitness computation should pribably depend on screen size... as is, on my ipad, half the time the fitness is just under 1 ror all entities, meaning that nobody gets a preference!

finally, as an aside,

abs(entitity.position - target.position) is a convienece method to get distance.

[Drizzel]

@JonB great, thanks a lot!

[Nitrous9123]

@JonB said:

a=[1,2,3]
b=a
b.append(4)
a
[1, 2, 3, 4]

I had a similar problem so I change the a to a tuple and the copied it to b. I needed to pop() from b but keep a unchanged so I can reset it to b at start over in my script

a=(1,2,3)
b=list(a)
b.append(4)
a
[1, 2, 3]