Wieder einmal ist es Zeit für eine Programmversion. Gegenüber dem letzten Mal hat sich viel verändert. Zum einen wird jetzt git als Version-Control-System eingesetzt, daher auch der obige Screenshot. Der Grund ist, dass sich damit der Sourcecode leichter memorieren lässt. Zum ersten Mal ist es möglich, den kompletten Sourcecode auswendig zu lernen. Git ist vergleichbar mit einem Vokabeltrainer.
Inhaltlich wurde auf die Box2D Physik-Engine verzichtet. Stattdessen wird eine Makrosimulation genutzt, wo also nur angedeutet wird, wie sich das Auto auf der Straße bewegt. Dadurch braucht man weniger Lines of Code und das Programm ist leichter für außenstehende verständlich. Trotzdem bleibt der Aufwand um die Behavior Trees zu erstellen unverändert hoch. Und hier ist nach wie vor der Flaschenhals. Aktuell hat das Programm nur 3-4 Tasks die implementiert wurden (followpoint, followwaygraph usw.). Die Leistungsfähigkeit der Künstlichen Intelligenz hängt davon ab, wieviele Actions / Behavior man implementiert. Leider ist jedoch das manuelle Coden dieser Behavior sehr zeitaufwendig.
# coding: utf8
'''
to do: rechteckiges auto
titel: selfdriving car
date: June 26, 2017
Anleitung: https://wiki.ubuntuusers.de/Git/
neues Projekt erzeugen: git init
Datei hinzufügen: git add 1.py
Änderung hinzufügen: git commit -am "AENDERUNGSBESCHREIBUNG"
Show:
git log
git status
GUI: gitk --all
Branches:
neuen Branch: git branch issue12
Branch wechseln: git checkout issue12
merge: git checkout master
git merge --no-ff ssue12
Branch löschen: git branch -d issue12
'''
import pygame, random, math, threading, sys
class Settings(object):
def __init__(self):
self.screen = (600, 338)
self.fps = 20 # 30 fps
self.white = (220, 220, 220)
self.black = (0, 0, 0)
self.grey = (150, 150, 150)
self.red = (230, 0, 0)
self.blue = (0, 0, 230)
def calcdistance(self, p1, p2):
""" Euclidean ordinary distance """
return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
def angle_between_two_points(self, p1, p2):
angle = math.degrees(math.atan2(p2[1] - p1[1], p2[0] - p1[0]))
angle += 90
if angle < 0: angle += 360
return angle
def floattoint(self, p):
return (int(p[0]), int(p[1]))
def polarpoint(self, p1, angle, radius):
""" polar coordinates for a point on circle """
angle = (angle - 90) * math.pi / 180
x = p1[0] + radius * math.cos(angle)
y = p1[1] + radius * math.sin(angle)
x,y=self.floattoint((x,y))
return (x, y)
def incircle(self,p1,radius,p2):
""" checks if p2 is in circle """
square_dist = (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2
return square_dist <= radius ** 2
class Physics(Settings):
def __init__(self):
super(Physics, self).__init__()
self.pos = (40,150)
self.radius=20
class Dictionary(Physics):
def __init__(self):
super(Dictionary, self).__init__()
self.primitive =[] # group, name, taskname
self.primitive.append(("move","path","taskfollowpath()"))
self.primitive.append(("move","waypoint","taskfollowwaypoints()"))
self.primitive.append(("move","mouse","taskmove()"))
self.primitive.append(("radius","smaller","task2()"))
self.primitive.append(("pos","right","taskright()"))
self.primitive.append(("pos","left","taskleft()"))
self.primitive.append(("-","-","misc()"))
self.primitive.append(("-","-","misc()"))
self.linestart=0
self.linemax=5
def taskmenu(self):
self.status="Running"
temp = self.menuselect1
taskname="self."+ self.primitive[temp][2]
eval(taskname)
self.status="Ready"
def pause(self,frames):
for i in range(frames):
self.updateGUI()
def movetoangle(self,angle):
radius=3
self.pos=self.polarpoint(self.pos, angle, radius)
def movetopos(self,goal):
for i in range(1000):
dist=self.calcdistance(goal,self.pos)
angle=self.angle_between_two_points(self.pos,goal)
print angle
self.movetoangle(angle)
self.pause(1)
if dist<10: break
def taskmove(self):
self.movetopos(self.mouse)
def task2(self):
for i in range(10):
self.radius-=1
self.pause(1)
def taskright(self):
p=(self.pos[0]+50,self.pos[1])
self.movetopos(p)
def taskleft(self):
p=(self.pos[0]-50,self.pos[1])
self.movetopos(p)
class Waypoints(Dictionary):
def __init__(self):
super(Waypoints, self).__init__()
# graph
self.node=[] # x,y
self.node.append((54,290))
self.node.append((300,290))
self.node.append((530,180))
self.node.append((150,150))
self.path=[] # waypoint
self.path.append(0)
self.path.append(2)
self.path.append(0)
self.path.append(1)
def taskfollowwaypoints(self):
for i in range(len(self.node)):
self.movetopos(self.node[i])
def taskfollowpath(self):
for i in range(len(self.path)):
self.movetopos(self.node[self.path[i]])
class GUI(Waypoints):
def __init__(self):
super(GUI, self).__init__()
random.seed()
pygame.init()
self.window = pygame.display.set_mode(self.screen)
self.mouse = (0, 0)
self.menuselect1 = 0
self.control = 1 # mode
self.status="Ready"
def updateGUI(self):
pygame.time.wait(1000/self.fps)
self.window.fill(self.white)
self.painttext()
self.paintmenu()
self.paintobjects()
pygame.display.update()
self.inputhandling()
def painttext(self):
# mouse
myfont = pygame.font.SysFont("freesans", 16)
text = str(self.control)+" " + str(self.mouse)+" "+str(self.step)
label = myfont.render(text, True, self.black)
self.window.blit(label, (220,30))
def paintmenu(self):
myfont = pygame.font.SysFont("freesans", 16)
count=0
xstart, ystart=400,15
height=18
for i in range(self.linestart,self.linestart+self.linemax):
# select
color=self.black
if self.menuselect1==i:
color=self.blue
if self.status=="Running": color=self.red # running color
label = myfont.render(">", True, color)
self.window.blit(label, (xstart-10,ystart+count*height))
# scrolling
self.linestart=self.menuselect1-(self.linemax/2)
if self.linestart<0: self.linestart=0
elif self.linestart>len(self.primitive)-self.linemax:
self.linestart=len(self.primitive)-self.linemax
# textout
if self.primitive[i][0]==self.primitive[i-1][0]: text = str(i)
else: text = str(i)+" "+self.primitive[i][0]
label = myfont.render(text, True, color)
self.window.blit(label, (xstart,ystart+count*height))
label = myfont.render(self.primitive[i][1], True, color)
self.window.blit(label, (xstart+90,ystart+count*height))
count+=1
def paintobjects(self):
# robot
pygame.draw.circle(self.window, self.blue, self.pos, self.radius, 0)
# waypoint
myfont = pygame.font.SysFont("freesans", 14)
for i in range(len(self.node)):
pygame.draw.circle(self.window, self.black, self.node[i], 3, 0)
label = myfont.render(str(i), True, self.black)
self.window.blit(label, self.node[i])
# path
for i in range(len(self.path)-1):
p1 = self.node[self.path[i]]
p2 = self.node[self.path[i+1]]
pygame.draw.line(self.window, self.blue, p1, p2, 1)
def inputhandling(self):
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit(0)
if event.type == pygame.MOUSEMOTION:
self.mouse = event.pos
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1: pass
if event.key == pygame.K_2: pass
if event.key == pygame.K_UP:
temp=self.menuselect1-1
if temp==-1: temp=len(self.primitive)-1
self.menuselect1=temp
if event.key == pygame.K_DOWN:
temp=self.menuselect1+1
if temp==len(self.primitive): temp=0
self.menuselect1=temp
if event.key == pygame.K_RIGHT: self.taskmenu()
class Game:
def __init__(self):
self.myGUI = GUI()
for self.myGUI.step in range(10000000):
self.myGUI.updateGUI()
if __name__ == "__main__":
myGame = Game()
