informaniac
/
blup
forked from Blinkenbunt/blup
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Browse Source

overall improvements

master
Fr3deric 8 years ago committed by Frederic
parent
6e27754069
commit
03077f7f74
3 changed files with 635 additions and 404 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 225
      balancep0ng.py
  2. 796
      pong.py
  3. BIN
      pongblib1.wav

225
balancep0ng.py
Unescape View File

@ -0,0 +1,225 @@
#!/usr/bin/python3
import time
import threading
import sys
import os
import configparser
import socket
import struct
import blup.frame
import blup.output
import pong
import subprocess
logo = [
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[1,1,1,0,1,1,1,1,0,1,0,0,1,0,0,1,1,0],
[1,0,1,0,1,0,0,1,0,1,1,0,1,0,1,0,0,1],
[1,0,1,0,1,0,0,1,0,1,0,1,1,0,1,0,0,0],
[1,1,1,0,1,0,0,1,0,1,0,0,1,0,1,0,1,1],
[1,0,0,0,1,0,0,1,0,1,0,0,1,0,1,0,0,1],
[1,0,0,0,1,1,1,1,0,1,0,0,1,0,0,1,1,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
]
logo_go = [
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,0],
[0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0],
[0,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,0],
[0,0,0,0,1,0,1,1,0,1,0,0,1,0,0,0,0,0],
[0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0],
[0,0,0,0,0,1,1,0,0,1,1,1,1,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
]
onePlayer = [
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,1,1,0,0,1,1,1,1,0,0,0,1,1,1,0,0],
[0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0],
[0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,1,0,0],
[0,0,0,1,0,0,1,1,1,1,0,0,0,0,1,0,0,0],
[0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
[0,0,1,1,1,0,1,0,0,0,0,0,0,0,1,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
]
__MAX_SCORE__ = 5
def mk_logo_frame(dimension, logo):
frame = blup.frame.Frame(dimension)
color = pong.getRandomColor(dimension.depth - 1)
xoffs = (dimension.width - len(logo[0])) // 2
yoffs = (dimension.height - len(logo)) // 2
for x in range(len(logo[0])):
for y in range(len(logo)):
if logo[y][x] == 1:
frame.setPixel(xoffs + x, yoffs + y, color)
return frame
def convertPixels(dimension, pixels, invert=False):
p = []
maxval = dimension.depth - 1
color = pong.getRandomColor(maxval)
for i in range(len(pixels)):
row = []
for j in range(len(pixels[i])):
if pixels[i][j] == (1 if not invert else 0):
row.append(color)
else:
row.append((0,0,0))
p.append(row)
return p
def get_balance_from_sock(sock, player_id):
print('will balance haben...')
sock.send(b'a')
data = sock.recv(4)
p1x, p1y, p2x, p2y = struct.unpack('bbbb', data)
if player_id == 0:
bal = p1y
elif player_id == 1:
bal = p2y
print('balance id=%s balance=%d' % (player_id, bal))
return bal
class BalanceBoardPlayer(object):
def __init__(self, playground, ownPaddle, wiimote_sock, player_id):
self.__playground = playground
self.__ownPaddle = ownPaddle
self.__wiimote = wiimote_sock
self.__ready = False
self.__playground.addGameTickCallback(self.gametickcb)
self.__wiimote_sock = wiimote_sock
self.__player_id = player_id
@property
def ownPaddle(self):
return self.__ownPaddle
@property
def ready(self):
return true
def gametickcb(self):
bal = get_balance_from_sock(self.__wiimote_sock, self.__player_id)
if bal == -128:
print("player %d has quit" % (self.__player_id))
self.__wiimote_sock.close()
sys.exit(1)
MAX_AMPLITUDE = 65
if bal < -MAX_AMPLITUDE:
bal = -MAX_AMPLITUDE
elif bal > MAX_AMPLITUDE:
bal = MAX_AMPLITUDE
bal += MAX_AMPLITUDE
pos = int((bal / (2 * MAX_AMPLITUDE)) * self.__playground.height)
print("player %d pos=%d" % (self.__player_id, pos))
if self.__ownPaddle.ypos > pos:
self.__ownPaddle.nextMoveUp()
elif self.__ownPaddle.ypos < pos:
self.__ownPaddle.nextMoveDown()
class B4lancePong(object):
def __init__(self, out, color=True):
self.__playground = None
self.__out = out
self.__color = color
if color:
self.__dimension = blup.frame.FrameDimension(22, 16, 256, 3)
else:
self.__dimension = blup.frame.FrameDimension(18, 8, 2, 1)
def runGame(self):
print('starting a game...')
scoreLeft = 0
scoreRight = 0
self.__playground = pong.Playground(self.__dimension.width, self.__dimension.height, 5)
pp = pong.PlaygroundPainter(out, self.__dimension, self.__playground)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#sock.connect(('localhost', 4711))
sock.connect(('blinkenbunt', 4711))
print('connected!')
while get_balance_from_sock(sock, 0) == -128:
print('waiting for player...')
time.sleep(1)
self.__players = []
self.__players.append(BalanceBoardPlayer(self.__playground, self.__playground.leftPaddle, sock, 0))
global logo
for i in range(5):
frame = mk_logo_frame(self.__dimension, onePlayer)
self.__out.sendFrame(frame)
print('waiting for second player...')
if get_balance_from_sock(sock, 1) > -128:
self.__players.append(BalanceBoardPlayer(self.__playground, self.__playground.rightPaddle, sock, 1))
break
time.sleep(1)
frame = mk_logo_frame(self.__dimension, logo)
self.__out.sendFrame(frame)
time.sleep(2)
def blib(obj):
if isinstance(obj, pong.Paddle):
subprocess.Popen(['mplayer','pongblib1.wav'])
self.__playground.ball.addHitCallback(blib)
frame = mk_logo_frame(self.__dimension, logo_go)
self.__out.sendFrame(frame)
time.sleep(1)
if len(self.__players) == 1:
bot = pong.PongBot(self.__playground, self.__playground.rightPaddle, 3)
self.__players.append(bot)
while max(scoreLeft, scoreRight) < __MAX_SCORE__:
winner = self.__playground.play()
if winner is self.__players[0].ownPaddle:
scoreLeft += 1
else:
scoreRight += 1
pong.displayScore(self.__out, self.__dimension, scoreLeft, scoreRight, 3000)
for i in range(3):
frame = blup.frame.Frame(self.__dimension)
self.__out.sendFrame(frame)
time.sleep(0.5)
pong.displayScore(self.__out, self.__dimension, scoreLeft, scoreRight, 500)
frame = blup.frame.Frame(self.__dimension)
self.__out.sendFrame(frame)
self.__playground = None
self.__players = []
sock.close()
if len(sys.argv) > 1:
outspec = sys.argv[1]
else:
outspec = 'e3blp:localhost:4242'
out = blup.output.getOutput(outspec)
p0ng = B4lancePong(out, color=True)
while True:
p0ng.runGame()
sys.exit(0)

796
pong.py
Unescape View File

@ -10,447 +10,453 @@ import blup.output
__numbers = { __numbers = {
1: [[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0,]], 1: [[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0,]],
2: [[1,1,1,1,1],[0,0,0,0,1],[1,1,1,1,1],[1,0,0,0,0],[1,1,1,1,1,]], 2: [[1,1,1,1,1],[0,0,0,0,1],[1,1,1,1,1],[1,0,0,0,0],[1,1,1,1,1,]],
3: [[1,1,1,1,1],[0,0,0,0,1],[0,0,1,1,1],[0,0,0,0,1],[1,1,1,1,1,]], 3: [[1,1,1,1,1],[0,0,0,0,1],[0,0,1,1,1],[0,0,0,0,1],[1,1,1,1,1,]],
4: [[1,0,0,0,1],[1,0,0,0,1],[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1,]], 4: [[1,0,0,0,1],[1,0,0,0,1],[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1,]],
5: [[1,1,1,1,1],[1,0,0,0,0],[1,1,1,1,1],[0,0,0,0,1],[1,1,1,1,1,]], 5: [[1,1,1,1,1],[1,0,0,0,0],[1,1,1,1,1],[0,0,0,0,1],[1,1,1,1,1,]],
6: [[1,1,1,1,1],[1,0,0,0,0],[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1,]], 6: [[1,1,1,1,1],[1,0,0,0,0],[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1,]],
7: [[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,0,1,]], 7: [[1,1,1,1,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,0,1],[0,0,0,0,1,]],
8: [[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1,]], 8: [[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1,]],
9: [[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1],[0,0,0,0,1],[1,1,1,1,1,]], 9: [[1,1,1,1,1],[1,0,0,0,1],[1,1,1,1,1],[0,0,0,0,1],[1,1,1,1,1,]],
0: [[1,1,1,1,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,1,1,1,1,]], 0: [[1,1,1,1,1],[1,0,0,0,1],[1,0,0,0,1],[1,0,0,0,1],[1,1,1,1,1,]],
} }
class Paddle(object): class Paddle(object):
def __init__(self, playground, xpos, ypos, size): def __init__(self, playground, xpos, ypos, size):
self.__playground = playground self.__playground = playground
self.__xpos = xpos self.__xpos = xpos
self.__size = size self.__size = size
self.__ypos = ypos self.__ypos = ypos
self.__nextMove = 0 self.__nextMove = 0
@property @property
def nextMove(self): def nextMove(self):
return self.__nextMove return self.__nextMove
@nextMove.setter @nextMove.setter
def nextMove(self, value): def nextMove(self, value):
if value in [-1, 0, 1]: if value in [-1, 0, 1]:
self.__nextMove = value self.__nextMove = value
else: else:
raise ValueError('invalid move') raise ValueError('invalid move')
@property @property
def xpos(self): def xpos(self):
return self.__xpos return self.__xpos
@property @property
def ypos(self): def ypos(self):
return self.__ypos return self.__ypos
@property @property
def size(self): def size(self):
return self.__size return self.__size
@property @property
def nextMove(self): def nextMove(self):
return self.__nextMove return self.__nextMove
def containsPoint(self, x, y): def containsPoint(self, x, y):
if x == self.__xpos and y in range(self.__ypos, self.__ypos + self.__size): if x == self.__xpos and y in range(self.__ypos, self.__ypos + self.__size):
return True return True
else: else:
return False return False
def nextMoveUp(self): def nextMoveUp(self):
self.__nextMove = -1 self.__nextMove = -1
def nextMoveDown(self): def nextMoveDown(self):
self.__nextMove = 1 self.__nextMove = 1
def doNextMove(self): def doNextMove(self):
if self.__nextMove is not 0: if self.__nextMove is not 0:
if self.__nextMove == -1 and self.__ypos > 0: if self.__nextMove == -1 and self.__ypos > 0:
self.__ypos -= 1 self.__ypos -= 1
elif self.__nextMove == 1 and self.__ypos + self.__size < self.__playground.height: elif self.__nextMove == 1 and self.__ypos + self.__size < self.__playground.height:
self.__ypos += 1 self.__ypos += 1
self.__nextMove = 0 self.__nextMove = 0
class Wall(object): class Wall(object):
HORIZONTAL = 1 HORIZONTAL = 1
VERTICAL = 2 VERTICAL = 2
def __init__(self, orientation): def __init__(self, orientation):
self.orientation = orientation self.orientation = orientation
class Ball(object): class Ball(object):
def __init__(self, playground, xpos, ypos, xspeed, yspeed): def __init__(self, playground, xpos, ypos, xspeed, yspeed):
self.__playground = playground self.__playground = playground
self.__xpos = xpos self.__xpos = xpos
self.__ypos = ypos self.__ypos = ypos
self.__xspeed = xspeed self.__xspeed = xspeed
self.__yspeed = yspeed self.__yspeed = yspeed
self.__hitCallbacks = [] self.__hitCallbacks = []
@property @property
def xpos(self): def xpos(self):
return self.__xpos return self.__xpos
@property @property
def ypos(self): def ypos(self):
return self.__ypos return self.__ypos
@property @property
def xspeed(self): def xspeed(self):
return self.__xspeed return self.__xspeed
@property @property
def yspeed(self): def yspeed(self):
return self.__yspeed return self.__yspeed
@xpos.setter @xpos.setter
def xpos(self, value): def xpos(self, value):
self.__xpos = value self.__xpos = value
@ypos.setter @ypos.setter
def ypos(self, value): def ypos(self, value):
self.__ypos = value self.__ypos = value
@xspeed.setter @xspeed.setter
def xspeed(self, value): def xspeed(self, value):
self.__xspeed = value self.__xspeed = value
@yspeed.setter @yspeed.setter
def yspeed(self, value): def yspeed(self, value):
self.__yspeed = value self.__yspeed = value
def addHitCallback(self, callback): def addHitCallback(self, callback):
self.__hitCallbacks.append(callback) self.__hitCallbacks.append(callback)
def doHitCallbacks(self, obj): def doHitCallbacks(self, obj):
for callback in self.__hitCallbacks: for callback in self.__hitCallbacks:
callback(obj) callback(obj)
def move(self, ignorePaddles=False): def move(self, ignorePaddles=False):
if self.__xspeed == 0 and self.__yspeed == 0: if self.__xspeed == 0 and self.__yspeed == 0:
return return
foundpos = False foundpos = False
while not foundpos: while not foundpos:
if self.__xspeed == 0 and self.__yspeed == 0: if self.__xspeed == 0 and self.__yspeed == 0:
break break
newx = self.__xpos + self.__xspeed newx = self.__xpos + self.__xspeed
newy = self.__ypos + self.__yspeed newy = self.__ypos + self.__yspeed
newobj = self.__playground.getObjectAtPosition(newx, newy) newobj = self.__playground.getObjectAtPosition(newx, newy)
if isinstance(newobj, Wall): if isinstance(newobj, Wall):
self.doHitCallbacks(newobj) self.doHitCallbacks(newobj)
# bounce off at horizontal wall # bounce off at horizontal wall
if newobj.orientation == Wall.HORIZONTAL: if newobj.orientation == Wall.HORIZONTAL:
self.__yspeed *= -1 self.__yspeed *= -1
else: else:
#self.__xspeed *= -1 #self.__xspeed *= -1
foundpos = True foundpos = True
elif isinstance(newobj, Paddle) and not ignorePaddles: elif isinstance(newobj, Paddle) and not ignorePaddles:
self.doHitCallbacks(newobj) self.doHitCallbacks(newobj)
self.__xspeed *= -1 self.__xspeed *= -1
# bounce off at the paddle # bounce off at the paddle
if self.__yspeed == 0: if self.__yspeed == 0:
if self.__playground.getObjectAtPosition(newobj.xpos, newobj.ypos - 1) is None: if self.__playground.getObjectAtPosition(newobj.xpos, newobj.ypos - 1) is None:
self.__yspeed = -1 self.__yspeed = -1
elif self.__plauground.getObjectAtPosition(newobj.xpos, newobj.ypos + 1) is None: elif self.__plauground.getObjectAtPosition(newobj.xpos, newobj.ypos + 1) is None:
self.__yspeed = 1 self.__yspeed = 1
else: else:
if newobj.xpos < self.__xpos: if newobj.xpos < self.__xpos:
if self.__playground.getObjectAtPosition(self.__xpos - 1, self.__ypos) is None: if self.__playground.getObjectAtPosition(self.__xpos - 1, self.__ypos) is None:
self.__yspeed *= -1 self.__yspeed *= -1
if newobj.xpos > self.__xpos: if newobj.xpos > self.__xpos:
if self.__playground.getObjectAtPosition(self.__xpos + 1, self.__ypos) is None: if self.__playground.getObjectAtPosition(self.__xpos + 1, self.__ypos) is None:
self.__yspeed *= -1 self.__yspeed *= -1
if newobj.nextMove != 0 and random.randint(0, 2) == 0: if newobj.nextMove != 0 and random.randint(0, 2) == 0:
self.__yspeed += newobj.nextMove self.__yspeed += newobj.nextMove
elif abs(self.__yspeed) != 1: elif abs(self.__yspeed) != 1:
self.__yspeed = 1 if self.__yspeed > 0 else -1 self.__yspeed = 1 if self.__yspeed > 0 else -1
else: else:
adjobj = self.__playground.getObjectAtPosition(newx, self.__ypos) adjobj = self.__playground.getObjectAtPosition(newx, self.__ypos)
if not ignorePaddles and isinstance(adjobj, Paddle): if not ignorePaddles and isinstance(adjobj, Paddle):
self.doHitCallbacks(adjobj) self.doHitCallbacks(adjobj)
self.__xspeed *= -1 self.__xspeed *= -1
else: else:
foundpos = True foundpos = True
self.__xpos = newx self.__xpos = newx
self.__ypos = newy self.__ypos = newy
class Playground(object): class Playground(object):
def __init__(self, width, height, paddlesize=3): def __init__(self, width, height, paddlesize=3):
self.__width = width self.__width = width
self.__height = height self.__height = height
paddleLeft = Paddle(self, 0, (height - paddlesize)/2, paddlesize) paddleLeft = Paddle(self, 0, (height - paddlesize)//2, paddlesize)
paddleRight = Paddle(self, width - 1, (height - paddlesize)/2, paddlesize) paddleRight = Paddle(self, width - 1, (height - paddlesize)//2, paddlesize)
self.__paddles = [paddleLeft, paddleRight] self.__paddles = [paddleLeft, paddleRight]
self.__ball = Ball(self, 0, 0, 1, 1) self.__ball = Ball(self, 0, 0, 1, 1)
self.__gameTickCallbacks = [] self.__gameTickCallbacks = []
self.__newRoundCallbacks = [] self.__newRoundCallbacks = []
@property @property
def width(self): def width(self):
return self.__width return self.__width
@property @property
def height(self): def height(self):
return self.__height return self.__height
@property @property
def leftPaddle(self): def leftPaddle(self):
return self.__paddles[0] return self.__paddles[0]
@property @property
def rightPaddle(self): def rightPaddle(self):
return self.__paddles[1] return self.__paddles[1]
@property @property
def ball(self): def ball(self):
return self.__ball return self.__ball
def containsPoint(self, x, y): def containsPoint(self, x, y):
if x >= 0 and x < self.width and y >= 0 and y < self.height: if x >= 0 and x < self.width and y >= 0 and y < self.height:
return True return True
else: else:
return False return False
def addGameTickCallback(self, callback): def addGameTickCallback(self, callback):
self.__gameTickCallbacks.append(callback) self.__gameTickCallbacks.append(callback)
print 'registered callback',callback print('registered callback',callback)
def addNewRoundCallback(self, callback): def addNewRoundCallback(self, callback):
self.__newRoundCallbacks.append(callback) self.__newRoundCallbacks.append(callback)
def getObjectAtPosition(self, x, y): def getObjectAtPosition(self, x, y):
if x >= self.__width or x < 0: if x >= self.__width or x < 0:
return Wall(Wall.VERTICAL) return Wall(Wall.VERTICAL)
elif y >= self.__height or y < 0: elif y >= self.__height or y < 0:
return Wall(Wall.HORIZONTAL) return Wall(Wall.HORIZONTAL)
elif y == self.__ball.ypos and x == self.__ball.xpos: elif y == self.__ball.ypos and x == self.__ball.xpos:
return self.__ball return self.__ball
else: else:
for paddle in self.__paddles: for paddle in self.__paddles:
if paddle.containsPoint(x, y): if paddle.containsPoint(x, y):
return paddle return paddle
def play(self, serve=None): def play(self, serve=None):
leftPaddle = self.__paddles[0] leftPaddle = self.__paddles[0]
rightPaddle = self.__paddles[1] rightPaddle = self.__paddles[1]
ball = self.__ball ball = self.__ball
if serve not in self.__paddles: if serve not in self.__paddles:
serve = self.__paddles[random.randint(0, 1)] serve = self.__paddles[random.randint(0, 1)]
ball.ypos = self.__height / 2 ball.ypos = self.__height // 2
ball.xpos = self.__width / 2 ball.xpos = self.__width // 2
if serve == rightPaddle and self.__width % 2 == 1: if serve == rightPaddle and self.__width % 2 == 1:
ball.xpos += 1 ball.xpos += 1
ball.yspeed = 0 ball.yspeed = 0
if serve == rightPaddle: if serve == rightPaddle:
ball.xspeed = 1 ball.xspeed = 1
else: else:
ball.yspeed = -1 ball.yspeed = -1
for callback in self.__newRoundCallbacks: for callback in self.__newRoundCallbacks:
callback() callback()
while True: ticks = 0
time.sleep(0.1) while True:
ball.move() ticks += 1
leftPaddle.doNextMove() time.sleep(0.08)
rightPaddle.doNextMove() if ticks %2 == 0:
ball.move()
if not self.containsPoint(ball.xpos, ball.ypos): leftPaddle.doNextMove()
break rightPaddle.doNextMove()
for callback in self.__gameTickCallbacks: if not self.containsPoint(ball.xpos, ball.ypos):
print callback break
callback()
for callback in self.__gameTickCallbacks:
if ball.xpos >= self.width: print(callback)
return leftPaddle callback()
elif ball.xpos <= 0:
return rightPaddle if ball.xpos >= self.width:
return leftPaddle
elif ball.xpos <= 0:
return rightPaddle
def getRandomColor(maxval): def getRandomColor(maxval):
return map(lambda x: int(round(x*maxval)), colorsys.hsv_to_rgb(random.random(), 1, 1)) return list(map(lambda x: int(round(x*maxval)), colorsys.hsv_to_rgb(random.random(), 1, 1)))
#return map(lambda x: int(round(x*maxval)), colorsys.hsv_to_rgb(random.random(), random.random(), random.random())) #return map(lambda x: int(round(x*maxval)), colorsys.hsv_to_rgb(random.random(), random.random(), random.random()))
class PlaygroundPainter(object): class PlaygroundPainter(object):
def __init__(self, out, dimension, playground): def __init__(self, out, dimension, playground):
self.__out = out self.__out = out
self.__playground = playground self.__playground = playground
self.__dimension = dimension self.__dimension = dimension
self.__playground.addGameTickCallback(self.update) self.__playground.addGameTickCallback(self.update)
self.__playground.ball.addHitCallback(self.ballhit) self.__playground.ball.addHitCallback(self.ballhit)
if dimension.channels == 1: if dimension.channels == 1:
self.__ballColor = 1 self.__ballColor = 1
self.__paddleColor = 1 self.__paddleColor = 1
else: else:
self.__ballColor = getRandomColor(dimension.depth - 1) self.__ballColor = getRandomColor(dimension.depth - 1)
self.__leftPaddleColor = getRandomColor(dimension.depth - 1) self.__leftPaddleColor = getRandomColor(dimension.depth - 1)
self.__rightPaddleColor = getRandomColor(dimension.depth - 1) self.__rightPaddleColor = getRandomColor(dimension.depth - 1)
def update(self): def update(self):
frame = blup.frame.Frame(self.__dimension) frame = blup.frame.Frame(self.__dimension)
#self.__paddleColor = getRandomColor(self.__dimension.depth - 1) #self.__paddleColor = getRandomColor(self.__dimension.depth - 1)
if self.__dimension.channels == 3: if self.__dimension.channels == 3:
for x in range(self.__dimension.width): for x in range(self.__dimension.width):
for y in range(self.__dimension.height): for y in range(self.__dimension.height):
frame.setPixel(x, y, (0,0,0)) frame.setPixel(x, y, (0,0,0))
frame.setPixel(self.__playground.ball.xpos, self.__playground.ball.ypos, self.__ballColor) frame.setPixel(self.__playground.ball.xpos, self.__playground.ball.ypos, self.__ballColor)
for i in range(self.__playground.leftPaddle.size): for i in range(self.__playground.leftPaddle.size):
frame.setPixel(self.__playground.leftPaddle.xpos, self.__playground.leftPaddle.ypos + i, self.__leftPaddleColor) frame.setPixel(self.__playground.leftPaddle.xpos, self.__playground.leftPaddle.ypos + i, self.__leftPaddleColor)
for i in range(self.__playground.rightPaddle.size): for i in range(self.__playground.rightPaddle.size):
frame.setPixel(self.__playground.rightPaddle.xpos, self.__playground.rightPaddle.ypos + i, self.__rightPaddleColor) frame.setPixel(self.__playground.rightPaddle.xpos, self.__playground.rightPaddle.ypos + i, self.__rightPaddleColor)
self.__out.sendFrame(frame) self.__out.sendFrame(frame)
def ballhit(self, obj): def ballhit(self, obj):
if self.__dimension.channels == 3: if self.__dimension.channels == 3:
if isinstance(obj, Paddle): if isinstance(obj, Paddle):
self.__ballColor = getRandomColor(self.__dimension.depth - 1) self.__ballColor = getRandomColor(self.__dimension.depth - 1)
if obj.xpos == 0: if obj.xpos == 0:
self.__leftPaddleColor = self.__ballColor self.__leftPaddleColor = self.__ballColor
else: else:
self.__rightPaddleColor = self.__ballColor self.__rightPaddleColor = self.__ballColor
class PongBot(object): class PongBot(object):
def __init__(self, playground, ownPaddle, dullness=0): def __init__(self, playground, ownPaddle, dullness=0):
self.__playground = playground self.__playground = playground
self.__ownPaddle = ownPaddle self.__ownPaddle = ownPaddle
self.__dullness = dullness self.__dullness = dullness
self.__playground.addGameTickCallback(self.onGameTick) self.__playground.addGameTickCallback(self.onGameTick)
self.__playground.addNewRoundCallback(self.onNewRound) self.__playground.addNewRoundCallback(self.onNewRound)
self.__playground.ball.addHitCallback(self.onHit) self.__playground.ball.addHitCallback(self.onHit)
self.__hitpoint = None self.__hitpoint = None
self.__oldHitpoint = None self.__oldHitpoint = None
self.__dull = False self.__dull = False
def updateHitpoint(self): def updateHitpoint(self):
origball = self.__playground.ball origball = self.__playground.ball
ball = Ball(self.__playground, origball.xpos, origball.ypos, origball.xspeed, origball.yspeed) ball = Ball(self.__playground, origball.xpos, origball.ypos, origball.xspeed, origball.yspeed)
ball.move() ball.move()
hitpoint = None hitpoint = None
while hitpoint is None: while hitpoint is None:
if ball.xpos >= self.__playground.width - 1 or ball.xpos <= 0: if ball.xpos >= self.__playground.width - 1 or ball.xpos <= 0:
hitpoint = (ball.xpos, ball.ypos) hitpoint = (ball.xpos, ball.ypos)
break break
ball.move(ignorePaddles=True) ball.move(ignorePaddles=True)
self.__oldHitpoint = self.__hitpoint self.__oldHitpoint = self.__hitpoint
self.__hitpoint = hitpoint self.__hitpoint = hitpoint
def onHit(self, obj): def onHit(self, obj):
print 'hit!', obj print('hit!', obj)
if isinstance(obj, Paddle) and obj is not self.__ownPaddle: if isinstance(obj, Paddle) and obj is not self.__ownPaddle:
self.updateHitpoint() self.updateHitpoint()
if self.__dullness > random.randint(0, 4): if self.__dullness > random.randint(0, 4):
self.__dull = True self.__dull = True
else: else:
self.__dull = False self.__dull = False
def onNewRound(self): def onNewRound(self):
self.updateHitpoint() self.updateHitpoint()
self.__oldHitpoint = None self.__oldHitpoint = None
self.__dull = False self.__dull = False
def onGameTick(self): def onGameTick(self):
#self.updateHitpoint() #self.updateHitpoint()
print 'hitpoint', self.__hitpoint print('hitpoint', self.__hitpoint)
(hitx, hity) = self.__hitpoint (hitx, hity) = self.__hitpoint
if hitx == self.__ownPaddle.xpos: if hitx == self.__ownPaddle.xpos:
if abs(self.__playground.ball.xpos - self.__ownPaddle.xpos) < 15: if abs(self.__playground.ball.xpos - self.__ownPaddle.xpos) < 15:
if not self.__dull: if not self.__dull:
if not self.__ownPaddle.containsPoint(hitx, hity): if not self.__ownPaddle.containsPoint(hitx, hity):
print 'moving!!' print('moving!!')
if self.__ownPaddle.ypos < hity: if self.__ownPaddle.ypos < hity:
self.__ownPaddle.nextMoveDown() self.__ownPaddle.nextMoveDown()
else: else:
self.__ownPaddle.nextMoveUp() self.__ownPaddle.nextMoveUp()
else: else:
if self.__ownPaddle.containsPoint(hitx, hity): if self.__ownPaddle.containsPoint(hitx, hity):
print 'moving!!' print('moving!!')
if hity < self.__ownPaddle.size: if hity < self.__ownPaddle.size:
self.__ownPaddle.nextMoveDown() self.__ownPaddle.nextMoveDown()
else: else:
self.__ownPaddle.nextMoveUp() self.__ownPaddle.nextMoveUp()
elif self.__dull: elif self.__dull:
r = random.randint(-1, 1) r = random.randint(-1, 1)
if r == -1: if r == -1:
self.__ownPaddle.nextMoveUp() self.__ownPaddle.nextMoveUp()
elif r == 1: elif r == 1:
self.__ownPaddle.nextMoveDown() self.__ownPaddle.nextMoveDown()
def displayScore(out, dimension, leftScore, rightScore, delay=0): def displayScore(out, dimension, leftScore, rightScore, delay=0):
leftNumber = __numbers[leftScore] leftNumber = __numbers[leftScore]
rightNumber = __numbers[rightScore] rightNumber = __numbers[rightScore]
frame = blup.frame.Frame(dimension) frame = blup.frame.Frame(dimension)
if dimension.channels == 1: if dimension.channels == 1:
dotcolor = 1 dotcolor = 1
numcolor = 1 numcolor = 1
else: else:
dotcolor = getRandomColor(dimension.depth - 1) dotcolor = getRandomColor(dimension.depth - 1)
numcolor = getRandomColor(dimension.depth - 1) numcolor = getRandomColor(dimension.depth - 1)
frame.setPixel(8, 1, dotcolor) xoffs = (dimension.width - 18) // 2
frame.setPixel(9, 1, dotcolor) yoffs = (dimension.height - 8) // 2
frame.setPixel(8, 2, dotcolor)
frame.setPixel(9, 2, dotcolor)
frame.setPixel(8, 4, dotcolor)
frame.setPixel(9, 4, dotcolor)
frame.setPixel(8, 5, dotcolor)
frame.setPixel(9, 5, dotcolor)
for x in range(5): frame.setPixel(xoffs + 8, yoffs + 1, dotcolor)
for y in range(5): frame.setPixel(xoffs + 9, yoffs + 1, dotcolor)
if leftNumber[y][x] == 1: frame.setPixel(xoffs + 8, yoffs + 2, dotcolor)
frame.setPixel(x+1, y+1, numcolor) frame.setPixel(xoffs + 9, yoffs + 2, dotcolor)
if rightNumber[y][x] == 1: frame.setPixel(xoffs + 8, yoffs + 4, dotcolor)
frame.setPixel(x+12, y+1, numcolor) frame.setPixel(xoffs + 9, yoffs + 4, dotcolor)
frame.setPixel(xoffs + 8, yoffs + 5, dotcolor)
frame.setPixel(xoffs + 9, yoffs + 5, dotcolor)
out.sendFrame(frame) for x in range(5):
if delay > 0: for y in range(5):
time.sleep(delay / 1000.0) if leftNumber[y][x] == 1:
frame.setPixel(xoffs + x+1, yoffs + y+1, numcolor)
if rightNumber[y][x] == 1:
frame.setPixel(xoffs + x+12, yoffs + y+1, numcolor)
out.sendFrame(frame)
if delay > 0:
time.sleep(delay / 1000.0)
def main(): def main():
print 'running a \'Bot vs. Bot\' round...' print('running a \'Bot vs. Bot\' round...')
#out = blup.output.getOutput('blp:localhost:42421') #out = blup.output.getOutput('blp:localhost:42421')
#out = blup.output.getOutput('e3blp:bastel0:4242') #out = blup.output.getOutput('e3blp:bastel0:4242')
out = blup.output.getOutput('e3blp:localhost:4242') out = blup.output.getOutput('e3blp:blinkenbunt:4242')
#out = blup.output.getOutput('e3blp:bbunt:42429') #out = blup.output.getOutput('e3blp:bbunt:42429')
#dim = blup.frame.FrameDimension(18, 8, 8, 3) #dim = blup.frame.FrameDimension(18, 8, 8, 3)
dim = blup.frame.FrameDimension(22, 16, 255, 3) dim = blup.frame.FrameDimension(22, 16, 255, 3)
playground = Playground(22, 16, paddlesize=4) playground = Playground(22, 16, paddlesize=4)
pp = PlaygroundPainter(out, dim, playground) pp = PlaygroundPainter(out, dim, playground)
leftPaddle = playground.leftPaddle leftPaddle = playground.leftPaddle
rightPaddle = playground.rightPaddle rightPaddle = playground.rightPaddle
ball = playground.ball ball = playground.ball
leftBot = PongBot(playground, leftPaddle, 1) leftBot = PongBot(playground, leftPaddle, 1)
rightBot = PongBot(playground, rightPaddle, 1) rightBot = PongBot(playground, rightPaddle, 1)
print playground.play() print(playground.play())
if __name__ == '__main__': if __name__ == '__main__':
main() main()

BIN
pongblib1.wav
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save