The screenshot shows the running software which is a fully autonomous pid controller for controlling a beam. The system is able to detect semantic events and will execute actions like rollleft and kick the ball on the beam. Because the software is a bit complicated, i want to explain it step by step which makes it easy to reproduce it from scratch.
First, we need a gui window for showing verbose information and take the user’s input. It was created with the tkinter package in the lovely Python programming language. The main feature of the GUI window is the input box which is working similar to a text-console in UNIX. The user enters a command, for example “kick” and the robot in the game will act in realtime. If the tkinter package is not installed in your Python installation, this would be the right moment for doing so. And because installing new packages with pip is easy and well documented, it make sense to install also the pygame and the box2d package as well. We will need it in later steps.
#!/usr/bin/env Python
#-*- coding: utf-8 -*
import Tkinter, ScrolledText, math
from tkinter import ttk
class GUI:
def __init__(self):
self.tkwindow = Tkinter.Tk()
self.tkwindow.geometry("300x400+600+0") # place to right
self.tkwindow.bind('<Motion>', self.mousemotion)
self.tkwindow.bind("<Key>", self.inputhandling)
self.fps=20 # 20
self.framestep = 0
self.mouse = (0,0)
# info
self.widgetinfo = Tkinter.Label(self.tkwindow, text="info")
self.widgetinfo.place(x=10, y=0)
# message label
self.widgetmessagelabel = Tkinter.Label(self.tkwindow, text="messagelabel", wraplength=250, justify="left", font=("FixedSys", 9))
self.widgetmessagelabel.place(x=10, y=30)
# message
self.widgetmessage = ScrolledText.ScrolledText(self.tkwindow, width=38, height=8, wrap="word")
self.widgetmessage.place(x=10, y=210)
# input
self.widgetinput = Tkinter.Entry(self.tkwindow)
self.widgetinput.place(x=10, y=340)
self.widgetinput.bind("<Return>", self.parseinput)
# start loop
self.gameloop()
def mousemotion(self,event):
self.mouse=(event.x, event.y)
def parseinput(self, event):
pass
def inputhandling(self,event):
pass
def paintlabel(self):
result="fps "+str(self.fps)+" frame "+str(self.framestep)
result+=" mouse "+str(self.mouse[0])+" "+str(self.mouse[1])
self.widgetinfo.config(text=result)
def paintobjects(self):
pass
def printtext(self,text):
self.widgetmessage.insert(Tkinter.END, text)
self.widgetmessage.see(Tkinter.END) # scroll to end
def gameloop(self):
self.framestep +=1
self.paintlabel()
self.paintobjects()
self.tkwindow.after(1000/self.fps, self.gameloop) # call gameloop every tick
class Game:
def __init__(self):
self.mygui = GUI()
self.mygui.tkwindow.mainloop()
mygame = Game()
In the next step we are creating additional to the tkinter window a pygame window. Because there is a need for displaying the game itself. In theory, it’s possible to paint lines in tkinter directly, but pygame has better drawing primitives and it’s a dedicated game engine.
#!/usr/bin/env Python
#-*- coding: utf-8 -*
import Tkinter, ScrolledText, pygame, math
from tkinter import ttk
class GUI:
def __init__(self):
self.tkwindow = Tkinter.Tk()
self.tkwindow.geometry("300x400+600+0") # place to right
self.tkwindow.bind('<Motion>', self.mousemotion)
self.tkwindow.bind("<Key>", self.inputhandling)
self.pygamewindow = pygame.display.set_mode((500, 350), pygame.HWSURFACE | pygame.DOUBLEBUF)
self.fps=20 # 20
self.framestep = 0
self.mouse = (0,0)
# info
self.widgetinfo = Tkinter.Label(self.tkwindow, text="info")
self.widgetinfo.place(x=10, y=0)
# message label
self.widgetmessagelabel = Tkinter.Label(self.tkwindow, text="messagelabel", wraplength=250, justify="left", font=("FixedSys", 9))
self.widgetmessagelabel.place(x=10, y=30)
# message
self.widgetmessage = ScrolledText.ScrolledText(self.tkwindow, width=38, height=8, wrap="word")
self.widgetmessage.place(x=10, y=210)
# input
self.widgetinput = Tkinter.Entry(self.tkwindow)
self.widgetinput.place(x=10, y=340)
self.widgetinput.bind("<Return>", self.parseinput)
# start loop
self.gameloop()
def mousemotion(self,event):
self.mouse=(event.x, event.y)
def parseinput(self, event):
pass
def inputhandling(self,event):
pass
def paintlabel(self):
result="fps "+str(self.fps)+" frame "+str(self.framestep)
result+=" mouse "+str(self.mouse[0])+" "+str(self.mouse[1])
self.widgetinfo.config(text=result)
# mousepos in pygame window
for event in pygame.event.get():
if event.type == pygame.MOUSEMOTION:
self.mouse=event.pos
def paintobjects(self):
self.pygamewindow.fill(pygame.Color(255,255,255))
def printtext(self,text):
self.widgetmessage.insert(Tkinter.END, text)
self.widgetmessage.see(Tkinter.END) # scroll to end
def gameloop(self):
self.framestep +=1
self.paintlabel()
self.paintobjects()
pygame.display.update()
self.tkwindow.after(1000/self.fps, self.gameloop) # call gameloop every tick
class Game:
def __init__(self):
self.mygui = GUI()
self.mygui.tkwindow.mainloop()
mygame = Game()
A game without a game-engine wouldn’t make much sense. For displaying a realistic “ball on a beam” situation, we need a fast underlying physics engine. It’s box2d, which works great in in Python together with pygame. For realizing it in sourcecode we need a second class which is stored in a new file. This helps to maintain the sourcecode short. The new file “box2d.py” contains everything what is needed to create a box2d instance, filling it with objects and activate a single joint. The idea is, that the user can move the beam left and right and this will change the ball’s position.
## file: main.py ##
#!/usr/bin/env Python
#-*- coding: utf-8 -*-
import Tkinter, ScrolledText, pygame, Box2D, math
from tkinter import ttk
import physics
class GUI:
def __init__(self):
self.tkwindow = Tkinter.Tk()
self.tkwindow.geometry("300x400+600+0") # place to right
self.tkwindow.bind('<Motion>', self.mousemotion)
self.tkwindow.bind("<Key>", self.inputhandling)
self.pygamewindow = pygame.display.set_mode((500, 350), pygame.HWSURFACE | pygame.DOUBLEBUF)
self.myphysics = physics.Physics()
self.fps=20 # 20
self.framestep = 0
self.mouse = (0,0)
self.ppm = 100.0 # pixels per meter, default 100
# info
self.widgetinfo = Tkinter.Label(self.tkwindow, text="info")
self.widgetinfo.place(x=10, y=0)
# message label
self.widgetmessagelabel = Tkinter.Label(self.tkwindow, text="messagelabel", wraplength=250, justify="left", font=("FixedSys", 9))
self.widgetmessagelabel.place(x=10, y=30)
# message
self.widgetmessage = ScrolledText.ScrolledText(self.tkwindow, width=38, height=8, wrap="word")
self.widgetmessage.place(x=10, y=210)
# input
self.widgetinput = Tkinter.Entry(self.tkwindow)
self.widgetinput.place(x=10, y=340)
self.widgetinput.bind("<Return>", self.parseinput)
# start loop
self.gameloop()
def mousemotion(self,event):
self.mouse=(event.x, event.y)
def parseinput(self, event):
pass
def inputhandling(self,event):
pass
def paintlabel(self):
result="fps "+str(self.fps)+" frame "+str(self.framestep)
result+=" mouse "+str(self.mouse[0])+" "+str(self.mouse[1])
self.widgetinfo.config(text=result)
# mousepos in pygame window
for event in pygame.event.get():
if event.type == pygame.MOUSEMOTION:
self.mouse=event.pos
def paintobjects(self):
self.pygamewindow.fill(pygame.Color(255,255,255))
colors = { Box2D.b2_staticBody: (16, 79, 15), Box2D.b2_dynamicBody: (165, 42, 42), }
for body in (self.myphysics.mybox2d.myworld.bodies):
for fixture in body.fixtures:
shape = fixture.shape
if hasattr(shape, 'vertices'): # rectangle
vertices = [(body.transform * v) * self.ppm for v in shape.vertices]
pygame.draw.polygon(self.pygamewindow, colors[body.type], vertices, 5)
else: # ball
position = body.transform * shape.pos * self.ppm
x, y = int(position[0]), int(position[1])
radius = int(shape.radius * self.ppm)
pygame.draw.circle(self.pygamewindow, colors[body.type], (x, y), radius, 2)
x2, y2 = x + radius * -math.sin(body.angle), y + radius * math.cos(body.angle)
pygame.draw.line(self.pygamewindow, colors[body.type], (x, y), (x2, y2), 2) #top
def printtext(self,text):
self.widgetmessage.insert(Tkinter.END, text)
self.widgetmessage.see(Tkinter.END) # scroll to end
def gameloop(self):
self.framestep +=1
self.paintlabel()
self.paintobjects()
pygame.display.update()
self.myphysics.update()
self.tkwindow.after(1000/self.fps, self.gameloop) # call gameloop every tick
class Game:
def __init__(self):
self.mygui = GUI()
self.mygui.tkwindow.mainloop()
mygame = Game()
## file: physics.py ##
import box2d
class Physics:
def __init__(self):
self.mybox2d = box2d.Box2d()
def update(self): self.mybox2d.update()
## file: box2d.py ##
import Box2D, math
class Box2d:
def __init__(self):
self.fps=20
self.fric = 0.2 # 1.0 friction
self.dens = 0.1 # 1.0 density
self.torque = 100 #100
self.reset()
def reset(self):
self.myworld = Box2D.b2World(gravity=(0,10), doSleep=True) # gravity=(0,10)
self.body = []
self.joint = []
self.createbox("static",(3, 3.3),(3, 0.02)) # bottom
self.createbox("static",(2.5, 2.0),(0.05, 0.05)) # fixed
self.createbox("dynamic",(2, 2),(1, 0.1)) # base
self.createcircle((2.3, 1.2),0.2) # ball
self.createrevolutejoint(1,2)
self.update()
def update(self):
timestep = 1.0 / self.fps
velocityIterations = 8
positionIterations = 3
self.myworld.Step(timestep, velocityIterations, positionIterations)
def createbox(self,moveable,p,size):
if moveable=="dynamic":
self.body.append(self.myworld.CreateDynamicBody(position=p, angle=0))
self.body[-1].CreatePolygonFixture(box=size, density=self.dens, friction=self.fric)
if moveable=="static":
self.body.append(self.myworld.CreateStaticBody(
position=p,angle=0,
fixtures=Box2D.b2FixtureDef(
shape=Box2D.b2PolygonShape(box=size),
friction=self.fric, density=self.dens
)
))
def createcircle(self,p,r):
self.body.append(self.myworld.CreateDynamicBody(
position=p,
fixtures=Box2D.b2FixtureDef(
shape=Box2D.b2CircleShape(radius=r),
restitution=0.5, density=self.dens, friction=self.fric),
))
def createrevolutejoint(self,id1,id2):
""" create rotating joint """
anchorA, anchorB = (0,0), (0,0)
self.joint.append(self.myworld.CreateRevoluteJoint(
bodyA=self.body[id1], bodyB=self.body[id2],
localAnchorA=anchorA, localAnchorB=anchorB,
enableMotor=True, enableLimit=False,
lowerAngle=0, upperAngle=1,
maxMotorTorque=self.torque,
motorSpeed=0,
))
def createprismaticjoint(self,id1,id2,axisx,axisy):
""" create linear joint """
self.joint.append(self.myworld.CreatePrismaticJoint(
bodyA=self.body[id1], bodyB=self.body[id2],
localAnchorA=(0, 0), localAnchorB=(0, 0), axis=(axisx, axisy),
lowerTranslation=1, upperTranslation=3.2,
enableMotor=True, enableLimit=False,
maxMotorForce=self.torque,
motorSpeed=0.0,
))
def getpos(self, id):
box2dpos = self.body[id].position
return self.box2d_to_pygame_pos(box2dpos)
def getvelocity(self, id):
return self.body[id].linearVelocity
def setspeed(self, id, speed):
self.joint[id].motorSpeed = speed
def getangle(self, id):
angle = self.body[id].angle
# angle = (math.degrees(angle)-90) % 360
angle = math.degrees(angle)
return angle
def box2d_to_pygame_pos(self, box2dpos):
""" convert coordinates """
ppm = 100.0 # pixels per meter, default 100
x,y = int(box2dpos[0] * ppm),int(box2dpos[1] * ppm)
return (x, y)
AI
The tutorial so far was about a simple Python game which consists of a tkinter GUI window, a pygame window and a box2d class. The simulation can be played manually by a human operator. But such a simulation alone is boring and many tutorials are available which are describing more sophisticated games. The more demanding task is to realize an Artificial Intelligence on top of the game. At first, i want to post the sourcecode itself, it contains the full blown game plus the integrated AI engine. The code is distributed over 5 files in around 400 lines of code. The good news is, that half of the content is known from the introduction. It’s the tkinter gui, the pygame window and the box2d engine. But something is new: a parser, a semantic grounding class and physics motion primitives.
### file: main.py ###
#!/usr/bin/env Python
#-*- coding: utf-8 -*-
import Tkinter, ScrolledText, pygame, Box2D, math
from tkinter import ttk
import physics
class GUI:
def __init__(self):
self.tkwindow = Tkinter.Tk()
self.tkwindow.geometry("300x400+600+0") # place to right
self.tkwindow.bind('<Motion>', self.mousemotion)
self.tkwindow.bind("<Key>", self.inputhandling)
self.pygamewindow = pygame.display.set_mode((500, 350), pygame.HWSURFACE | pygame.DOUBLEBUF)
self.myphysics = physics.Physics()
self.fps=20 # 20
self.framestep = 0
self.mouse = (0,0)
self.ppm = 100.0 # pixels per meter, default 100
# info
self.widgetinfo = Tkinter.Label(self.tkwindow, text="info")
self.widgetinfo.place(x=10, y=0)
# message label
self.widgetmessagelabel = Tkinter.Label(self.tkwindow, text="messagelabel", wraplength=250, justify="left", font=("FixedSys", 9))
self.widgetmessagelabel.place(x=10, y=30)
# message
self.widgetmessage = ScrolledText.ScrolledText(self.tkwindow, width=38, height=8, wrap="word")
self.widgetmessage.place(x=10, y=210)
# input
self.widgetinput = Tkinter.Entry(self.tkwindow)
self.widgetinput.place(x=10, y=340)
self.widgetinput.bind("<Return>", self.parseinput)
# start loop
self.gameloop()
def mousemotion(self,event):
self.mouse=(event.x, event.y)
def parseinput(self, event):
name=self.widgetinput.get()
self.myphysics.parser(name)
def inputhandling(self,event):
if event.keysym=="Left": self.myphysics.parser("rollleft")
if event.keysym=="Right": self.myphysics.parser("rollright")
if event.keysym=="Up": self.myphysics.parser("kick")
if event.keysym=="Down": self.myphysics.parser("kick2")
def paintlabel(self):
result="fps "+str(self.fps)+" frame "+str(self.framestep)
result+=" mouse "+str(self.mouse[0])+" "+str(self.mouse[1])
self.widgetinfo.config(text=result)
# physics message
temp= self.myphysics.myparser.message
if temp !="":
self.printtext(temp+" ")
self.myphysics.myparser.clearmessage()
# wordlist and info
temp = self.myphysics.myparser.getwords()+"\n\n"
temp += self.myphysics.getinfo()
self.widgetmessagelabel.config(text=temp)
# mousepos in pygame window
for event in pygame.event.get():
if event.type == pygame.MOUSEMOTION:
self.mouse=event.pos
def paintobjects(self):
self.pygamewindow.fill(pygame.Color(255,255,255))
colors = { Box2D.b2_staticBody: (16, 79, 15), Box2D.b2_dynamicBody: (165, 42, 42), }
for body in (self.myphysics.mybox2d.myworld.bodies):
for fixture in body.fixtures:
shape = fixture.shape
if hasattr(shape, 'vertices'): # rectangle
vertices = [(body.transform * v) * self.ppm for v in shape.vertices]
pygame.draw.polygon(self.pygamewindow, colors[body.type], vertices, 5)
else: # ball
position = body.transform * shape.pos * self.ppm
x, y = int(position[0]), int(position[1])
radius = int(shape.radius * self.ppm)
pygame.draw.circle(self.pygamewindow, colors[body.type], (x, y), radius, 2)
x2, y2 = x + radius * -math.sin(body.angle), y + radius * math.cos(body.angle)
pygame.draw.line(self.pygamewindow, colors[body.type], (x, y), (x2, y2), 2) #top
def printtext(self,text):
self.widgetmessage.insert(Tkinter.END, text)
self.widgetmessage.see(Tkinter.END) # scroll to end
def gameloop(self):
self.framestep +=1
self.paintlabel()
self.paintobjects()
pygame.display.update()
self.myphysics.update()
self.tkwindow.after(1000/self.fps, self.gameloop) # call gameloop every tick
class Game:
def __init__(self):
self.mygui = GUI()
self.mygui.tkwindow.mainloop()
mygame = Game()
### file: grounding.py ###
class Lookuptable:
""" constructor needs a dictionary at first run"""
def __init__(self,category):
self.mydict=category
def search(self,target):
errormin=9999
itemmin=-1
for i in self.mydict.items():
error=abs(i[0]-target)
if error<errormin:
errormin=error
itemmin=i
return itemmin[1]
class Grounding:
def __init__(self):
self.position=Lookuptable({125:'leftoff',165:'leftcorner',205:'left',245:'middle',
285:'right',325:'rightcorner',365:'rightoff'})
self.velocity = Lookuptable({-.4:'moveleftfast',-.1:'moveleft',
.0:'standstill',.1:'moveright',.4:'moverightfast'})
self.distance=Lookuptable({0:'contact',20:'near',40:'away',60:'faraway'})
def get(self,name,value):
# for example: self.get("pos",-2.1)
if name=="pos": return self.position.search(value)
if name=="vel": return self.velocity.search(value)
if name=="distance": return self.distance.search(value)
### file: physics.py ###
import threading,time
import box2d, parser, grounding
class Physics:
def __init__(self):
self.mybox2d = box2d.Box2d()
self.myparser = parser.Parser()
self.mygrounding = grounding.Grounding()
self.mainrunning=False
def parser(self,name):
status=self.myparser.getcommand(name)
if status!="error":
# run every command as thread
command="self."+status[0]
argument=status[1]
thread1 = threading.Thread(target=eval(command),args=argument)
thread1.daemon = True # stops, if mainprogram ends
thread1.start()
def update(self): self.mybox2d.update()
def reset(self): self.mybox2d.reset()
def setmotor(self,speed): self.mybox2d.setspeed(0,speed)
def getangle(self): return self.mybox2d.getangle(2)
def getballpos(self): return self.mybox2d.getpos(3)
def getballspeed(self): return self.mybox2d.getvelocity(3) # b2vec
def getsemanticpos(self): return self.mygrounding.get("pos",self.getballpos()[0])
def getsemanticvel(self): return self.mygrounding.get("vel",self.getballspeed()[0])
def reachangle(self, target, initspeed):
""" example execution: 20,2 (angle=20, speed=2) """
speed=initspeed
for i in range(100):
angle=self.getangle()
diff=angle-target
#print i, diff, speed
if diff<0: self.setmotor(speed)
if diff>0: self.setmotor(-speed)
if abs(diff)<5: speed=abs(diff)/5.0
if abs(diff)<0.5:
self.setmotor(0)
break
time.sleep(0.05)
def roll(self, direction):
# direction: -3 strongleft, -1 lowleft, 1 lowright
angle=2*direction
self.reachangle(angle,1)
time.sleep(.5)
self.reachangle(0,1)
def kick(self, direction):
# direction = -1 or 1
self.setmotor(7*direction)
time.sleep(0.1)
self.setmotor(0)
time.sleep(0.1)
self.setmotor(-7*direction)
time.sleep(0.1)
self.setmotor(0)
self.reachangle(0,2) # back to init
def kick2(self):
speed=6 #6
duration=0.15
self.setmotor(speed)
time.sleep(duration)
self.setmotor(0)
time.sleep(0.1)
self.setmotor(-speed)
time.sleep(duration+.1)
self.setmotor(0)
self.reachangle(0,2) # back to init
def getinfo(self):
result=""
result+="semantic "
result+=self.getsemanticpos()+" "
result+=self.getsemanticvel()
result+=" ballpos="+str(self.getballpos())
x=round(self.getballspeed()[0],1)
y=round(self.getballspeed()[0],2)
result+=" speed="+str(x)+" "+str(y)
result+=" angle="+str(int(self.getangle()))
result+=" threadrunning="+str(self.mainrunning)
return result
def detectdanger(self):
pos=self.getsemanticpos()
vel=self.getsemanticvel()
if pos=="rightcorner":
if vel=="moveright":
self.myparser.addmessage("rightdanger")
self.roll(-3)
if vel=="moverightfast":
self.myparser.addmessage("rightdangerhigh")
self.roll(-5)
if pos=="leftcorner":
if vel=="moveleft":
self.myparser.addmessage("leftdanger")
self.roll(3)
if vel=="moveleftfast":
self.myparser.addmessage("leftdangerhigh")
self.roll(5)
def detectkick(self):
pos=self.getsemanticpos()
vel=self.getsemanticvel()
# detect kick
if pos=="right" and (vel=="moveright" or vel=="moverightfast"):
self.kick(-1)
def detectoff(self):
pos=self.getsemanticpos()
vel=self.getsemanticvel()
if pos=="leftoff" or pos=="rightoff":
self.reset()
def mainstop(self):
self.mainrunning=False
def main(self):
self.mainrunning=True
for i in range(10000):
time.sleep(.2)
self.detectdanger()
self.detectkick()
self.detectoff()
if self.mainrunning==False:
break
self.mainrunning=False
### file: parser.py ###
class Parser:
def __init__(self):
self.message = ""
self.words =[ # ("name","group","command",[parameter])
("words","system","words",[]), # dummy
("info","system","getinfo",[]), # dummy
("reset","system","reset",[]),
("stop","motor","setmotor",[0]),
("left","motor","setmotor",[-0.3]),
("right","motor","setmotor",[0.3]),
("reach-20","reach","reachangle",[-20,2]),
("reach+20","reach","reachangle",[20,2]),
("rollleft","roll","roll",[-2]),
("rollright",",roll","roll",[2]),
("kick","kick","kick",[-1]),
("kick2","kick","kick2",[]),
("main","macro","main",[]),
("mainstop","macro","mainstop",[]),
]
def clearmessage(self):
self.message=""
def addmessage(self,text):
self.message+=text
def getwords(self):
result=""
for i in self.words:
result+=i[0]+" "
return result
def getcommand(self,name):
result=[]
self.addmessage(name)
pos=self.findword(name)
if pos!=-1:
result.append(self.words[pos][2]) # command
result.append(self.words[pos][3]) # parameter
else:
result="error"
self.addmessage("command not found\n")
return result
def findword(self,name):
pos=-1
for i in range(len(self.words)):
if self.words[i][0]==name:
pos=i
break
return pos
### file: box2d.py ###
import Box2D, math
class Box2d:
def __init__(self):
self.fps=20
self.fric = 0.2 # 1.0 friction
self.dens = 0.1 # 1.0 density
self.torque = 100 #100
self.reset()
def reset(self):
self.myworld = Box2D.b2World(gravity=(0,10), doSleep=True) # gravity=(0,10)
self.body = []
self.joint = []
self.createbox("static",(3, 3.3),(3, 0.02)) # bottom
self.createbox("static",(2.5, 2.0),(0.05, 0.05)) # fixed
self.createbox("dynamic",(2, 2),(1, 0.1)) # base
self.createcircle((2.3, 1.2),0.2) # ball
self.createrevolutejoint(1,2)
self.update()
def update(self):
timestep = 1.0 / self.fps
velocityIterations = 8
positionIterations = 3
self.myworld.Step(timestep, velocityIterations, positionIterations)
def createbox(self,moveable,p,size):
if moveable=="dynamic":
self.body.append(self.myworld.CreateDynamicBody(position=p, angle=0))
self.body[-1].CreatePolygonFixture(box=size, density=self.dens, friction=self.fric)
if moveable=="static":
self.body.append(self.myworld.CreateStaticBody(
position=p,angle=0,
fixtures=Box2D.b2FixtureDef(
shape=Box2D.b2PolygonShape(box=size),
friction=self.fric, density=self.dens
)
))
def createcircle(self,p,r):
self.body.append(self.myworld.CreateDynamicBody(
position=p,
fixtures=Box2D.b2FixtureDef(
shape=Box2D.b2CircleShape(radius=r),
restitution=0.5, density=self.dens, friction=self.fric),
))
def createrevolutejoint(self,id1,id2):
""" create rotating joint """
anchorA, anchorB = (0,0), (0,0)
self.joint.append(self.myworld.CreateRevoluteJoint(
bodyA=self.body[id1], bodyB=self.body[id2],
localAnchorA=anchorA, localAnchorB=anchorB,
enableMotor=True, enableLimit=False,
lowerAngle=0, upperAngle=1,
maxMotorTorque=self.torque,
motorSpeed=0,
))
def createprismaticjoint(self,id1,id2,axisx,axisy):
""" create linear joint """
self.joint.append(self.myworld.CreatePrismaticJoint(
bodyA=self.body[id1], bodyB=self.body[id2],
localAnchorA=(0, 0), localAnchorB=(0, 0), axis=(axisx, axisy),
lowerTranslation=1, upperTranslation=3.2,
enableMotor=True, enableLimit=False,
maxMotorForce=self.torque,
motorSpeed=0.0,
))
def getpos(self, id):
box2dpos = self.body[id].position
return self.box2d_to_pygame_pos(box2dpos)
def getvelocity(self, id):
return self.body[id].linearVelocity
def setspeed(self, id, speed):
self.joint[id].motorSpeed = speed
def getangle(self, id):
angle = self.body[id].angle
# angle = (math.degrees(angle)-90) % 360
angle = math.degrees(angle)
return angle
def box2d_to_pygame_pos(self, box2dpos):
""" convert coordinates """
ppm = 100.0 # pixels per meter, default 100
x,y = int(box2dpos[0] * ppm),int(box2dpos[1] * ppm)
return (x, y)
The best idea is to start the description with the physics class. In contrast to the class in the introduction which was nearly empty, it has now some additional motion primitives. They are used for getting information, and executing actions. An example motion primitive is “rollleft” which will move the beam to the left. Most of the motion primitives are threaded, that means, they run in background. To executing the primitives, a dedicated parser is used. The parser takes the user’s input and determines which Python method has to be called. The parser is created around a dictionary.
At the end is another new class available, called grounding. This is used for converting absolute ball positions into natural language. It works also with a dictionary, and an example request would be that the ballposition x=245 is equal to “middle”. Such kind of mapping helps to create behaviors. Instead of writing “if ballx>230 and ballx<260”, the more simpler statement “if ball=middle” can be used. The AI itself is the physics.main() which is a short Python method used for determine the next action. It will check if the ball is on the beam and checks also if a kick is possible.
The physics.main() method can be started from the tkinter GUI window, and it's also possible to interrupt the task by request. The overall system is controlled interactively. That means, the user and the AI are working together. The user has the option to control the beam manual and overwrite the AI, or he can choose to deactivate the AI completely with the “mainstop” command.
Perhaps some words about the idea of the Artificial Intelligence. It's very similar to what Rodney Brooks has called behavior based robotics. The idea is, that the user has to create motion primitives and use these primitives for realizing high-level actions. This is called a hierarchical control system. In case of the domain “ball on beam” the motion primitives have names like “kick”, “rollleft”, “getballposition”. In case of a different domain, the motion primitives have to be changed. The means, it is not a general game playing architecture, but the software can be adjusted to new domains. So it is some kind of robot construction kit. The box2d engine and the parser are remaining the same, only the motion primitives have to be adapted to a new domain.
Class diagram
