blup/pong.py

#!/usr/bin/python

import time
import random
import sys
import colorsys

import blup.frame
import blup.output


__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,]],
	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,]],
	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,]],
	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,]],
	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,]],
	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):
	def __init__(self, playground, xpos, ypos, size):
		self.__playground = playground
		self.__xpos = xpos
		self.__size = size
		self.__ypos = ypos
		self.__nextMove = 0

	@property
	def nextMove(self):
		return self.__nextMove
	@nextMove.setter
	def nextMove(self, value):
		if value in [-1, 0, 1]:
			self.__nextMove = value
		else:
			raise ValueError('invalid move')

	@property
	def xpos(self):
		return self.__xpos
	@property
	def ypos(self):
		return self.__ypos
	@property
	def size(self):
		return self.__size
	@property
	def nextMove(self):
		return self.__nextMove

	def containsPoint(self, x, y):
		if x == self.__xpos and y in range(self.__ypos, self.__ypos + self.__size):
			return True
		else:
			return False

	def nextMoveUp(self):
		self.__nextMove = -1

	def nextMoveDown(self):
		self.__nextMove = 1

	def doNextMove(self):
		if self.__nextMove is not 0:
			if self.__nextMove == -1 and self.__ypos > 0:
				self.__ypos -= 1
			elif self.__nextMove == 1 and self.__ypos + self.__size < self.__playground.height:
				self.__ypos += 1
			self.__nextMove = 0

class Wall(object):
	HORIZONTAL = 1
	VERTICAL = 2
	def __init__(self, orientation):
		self.orientation = orientation

class Ball(object):
	def __init__(self, playground, xpos, ypos, xspeed, yspeed):
		self.__playground = playground
		self.__xpos = xpos
		self.__ypos = ypos
		self.__xspeed = xspeed
		self.__yspeed = yspeed
		self.__hitCallbacks = []

	@property
	def xpos(self):
		return self.__xpos
	@property
	def ypos(self):
		return self.__ypos
	@property
	def xspeed(self):
		return self.__xspeed
	@property
	def yspeed(self):
		return self.__yspeed
	@xpos.setter
	def xpos(self, value):
		self.__xpos = value
	@ypos.setter
	def ypos(self, value):
		self.__ypos = value
	@xspeed.setter
	def xspeed(self, value):
		self.__xspeed = value
	@yspeed.setter
	def yspeed(self, value):
		self.__yspeed = value

	def addHitCallback(self, callback):
		self.__hitCallbacks.append(callback)
	
	def doHitCallbacks(self, obj):
		for callback in self.__hitCallbacks:
			callback(obj)

	def move(self, ignorePaddles=False):
		if self.__xspeed == 0 and self.__yspeed == 0:
			return
		foundpos = False
		while not foundpos:
			if self.__xspeed == 0 and self.__yspeed == 0:
				break
			newx = self.__xpos + self.__xspeed
			newy = self.__ypos + self.__yspeed

			newobj = self.__playground.getObjectAtPosition(newx, newy)
			if isinstance(newobj, Wall):
				self.doHitCallbacks(newobj)

				# bounce off at horizontal wall
				if newobj.orientation == Wall.HORIZONTAL:
					self.__yspeed *= -1
				else:
					#self.__xspeed *= -1
					foundpos = True
			elif isinstance(newobj, Paddle) and not ignorePaddles:
				self.doHitCallbacks(newobj)
				self.__xspeed *= -1

				# bounce off at the paddle
				if self.__yspeed == 0:
					if self.__playground.getObjectAtPosition(newobj.xpos, newobj.ypos - 1) is None:
						self.__yspeed = -1
					elif self.__plauground.getObjectAtPosition(newobj.xpos, newobj.ypos + 1) is None:
						self.__yspeed = 1
				else:
					if newobj.xpos < self.__xpos:
						if self.__playground.getObjectAtPosition(self.__xpos - 1, self.__ypos) is None:
							self.__yspeed *= -1
					if newobj.xpos > self.__xpos:
						if self.__playground.getObjectAtPosition(self.__xpos + 1, self.__ypos) is None:
							self.__yspeed *= -1

				if newobj.nextMove != 0 and random.randint(0, 2) == 0:
					self.__yspeed += newobj.nextMove
				elif abs(self.__yspeed) != 1:
					self.__yspeed = 1 if self.__yspeed > 0 else -1
			else:
				adjobj = self.__playground.getObjectAtPosition(newx, self.__ypos)
				if not ignorePaddles and isinstance(adjobj, Paddle):
					self.doHitCallbacks(adjobj)
					self.__xspeed *= -1
				else:
					foundpos = True


		self.__xpos = newx
		self.__ypos = newy

class Playground(object):
	def __init__(self, width, height, paddlesize=3):
		self.__width = width
		self.__height = height

		paddleLeft = Paddle(self, 0, (height - paddlesize)/2, paddlesize)
		paddleRight = Paddle(self, width - 1, (height - paddlesize)/2, paddlesize)
		self.__paddles = [paddleLeft, paddleRight]

		self.__ball = Ball(self, 0, 0, 1, 1)
		self.__gameTickCallbacks = []
		self.__newRoundCallbacks = []

	@property
	def width(self):
		return self.__width
	@property
	def height(self):
		return self.__height
	@property
	def leftPaddle(self):
		return self.__paddles[0]
	@property
	def rightPaddle(self):
		return self.__paddles[1]
	@property
	def ball(self):
		return self.__ball

	def containsPoint(self, x, y):
		if x >= 0 and x < self.width and y >= 0 and y < self.height:
			return True
		else:
			return False

	def addGameTickCallback(self, callback):
		self.__gameTickCallbacks.append(callback)
		print 'registered callback',callback
	def addNewRoundCallback(self, callback):
		self.__newRoundCallbacks.append(callback)

	def getObjectAtPosition(self, x, y):
		if x >= self.__width or x < 0:
			return Wall(Wall.VERTICAL)
		elif y >= self.__height or y < 0:
			return Wall(Wall.HORIZONTAL)
		elif y == self.__ball.ypos and x == self.__ball.xpos:
			return self.__ball
		else:
			for paddle in self.__paddles:
				if paddle.containsPoint(x, y):
					return paddle

	def play(self, serve=None):
		leftPaddle = self.__paddles[0]
		rightPaddle = self.__paddles[1]
		ball = self.__ball

		if serve not in self.__paddles:
			serve = self.__paddles[random.randint(0, 1)]

		ball.ypos = self.__height / 2
		ball.xpos = self.__width / 2
		if serve == rightPaddle and self.__width % 2 == 1:
			ball.xpos += 1

		ball.yspeed = 0
		if serve == rightPaddle:
			ball.xspeed = 1
		else:
			ball.yspeed = -1

		for callback in self.__newRoundCallbacks:
			callback()

		while True:
			time.sleep(0.1)
			ball.move()
			leftPaddle.doNextMove()
			rightPaddle.doNextMove()

			if not self.containsPoint(ball.xpos, ball.ypos):
				break

			for callback in self.__gameTickCallbacks:
				print callback
				callback()

		if ball.xpos >= self.width:
			return leftPaddle
		elif ball.xpos <= 0:
			return rightPaddle


def getRandomColor(maxval):
	return 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())) 


class PlaygroundPainter(object):
	def __init__(self, out, dimension, playground):
		self.__out = out
		self.__playground = playground
		self.__dimension = dimension
		self.__playground.addGameTickCallback(self.update)
		self.__playground.ball.addHitCallback(self.ballhit)

		if dimension.channels == 1:
			self.__ballColor = 1
			self.__paddleColor = 1
		else:
			self.__ballColor = getRandomColor(dimension.depth - 1)
			self.__leftPaddleColor = getRandomColor(dimension.depth - 1)
			self.__rightPaddleColor = getRandomColor(dimension.depth - 1)

	def update(self):
		frame = blup.frame.Frame(self.__dimension)
		#self.__paddleColor = getRandomColor(self.__dimension.depth - 1)

		if self.__dimension.channels == 3:
			for x in range(self.__dimension.width):
				for y in range(self.__dimension.height):
					frame.setPixel(x, y, (0,0,0))

		frame.setPixel(self.__playground.ball.xpos, self.__playground.ball.ypos, self.__ballColor)

		for i in range(self.__playground.leftPaddle.size):
			frame.setPixel(self.__playground.leftPaddle.xpos, self.__playground.leftPaddle.ypos + i, self.__leftPaddleColor)
		for i in range(self.__playground.rightPaddle.size):
			frame.setPixel(self.__playground.rightPaddle.xpos, self.__playground.rightPaddle.ypos + i, self.__rightPaddleColor)

		self.__out.sendFrame(frame)
	
	def ballhit(self, obj):
		if self.__dimension.channels == 3:
			if isinstance(obj, Paddle):
				self.__ballColor = getRandomColor(self.__dimension.depth - 1)
				if obj.xpos == 0:
					self.__leftPaddleColor = self.__ballColor
				else:
					self.__rightPaddleColor = self.__ballColor
			
			



class PongBot(object):
	def __init__(self, playground, ownPaddle, dullness=0):
		self.__playground = playground
		self.__ownPaddle = ownPaddle
		self.__dullness = dullness
		self.__playground.addGameTickCallback(self.onGameTick)
		self.__playground.addNewRoundCallback(self.onNewRound)
		self.__playground.ball.addHitCallback(self.onHit)
		self.__hitpoint = None
		self.__oldHitpoint = None
		self.__dull = False

	def updateHitpoint(self):
		origball = self.__playground.ball
		ball = Ball(self.__playground, origball.xpos, origball.ypos, origball.xspeed, origball.yspeed)
		ball.move()
		hitpoint = None
		while hitpoint is None:
			if ball.xpos >= self.__playground.width - 1 or ball.xpos <= 0:
				hitpoint = (ball.xpos, ball.ypos)
				break

			ball.move(ignorePaddles=True)
		self.__oldHitpoint = self.__hitpoint
		self.__hitpoint = hitpoint

	def onHit(self, obj):
		print 'hit!', obj
		if isinstance(obj, Paddle) and obj is not self.__ownPaddle:
			self.updateHitpoint()

			if self.__dullness > random.randint(0, 4):
				self.__dull = True
			else:
				self.__dull = False
	
	def onNewRound(self):
		self.updateHitpoint()
		self.__oldHitpoint = None
		self.__dull = False

	def onGameTick(self):
		#self.updateHitpoint()
		print 'hitpoint', self.__hitpoint
		(hitx, hity) = self.__hitpoint



		if hitx == self.__ownPaddle.xpos:
			if abs(self.__playground.ball.xpos - self.__ownPaddle.xpos) < 15:
				if not self.__dull:
					if not self.__ownPaddle.containsPoint(hitx, hity):
						print 'moving!!'
						if self.__ownPaddle.ypos < hity:
							self.__ownPaddle.nextMoveDown()
						else:
							self.__ownPaddle.nextMoveUp()
				else:
					if self.__ownPaddle.containsPoint(hitx, hity):
						print 'moving!!'
						if hity < self.__ownPaddle.size:
							self.__ownPaddle.nextMoveDown()
						else:
							self.__ownPaddle.nextMoveUp()
		
			elif self.__dull:
				r = random.randint(-1, 1)
				if r == -1:
					self.__ownPaddle.nextMoveUp()
				elif r == 1:
					self.__ownPaddle.nextMoveDown()


def displayScore(out, dimension, leftScore, rightScore, delay=0):
	leftNumber = __numbers[leftScore]
	rightNumber = __numbers[rightScore]

	frame = blup.frame.Frame(dimension)

	if dimension.channels == 1:
		dotcolor = 1
		numcolor = 1
	else:
		dotcolor = getRandomColor(dimension.depth - 1)
		numcolor = getRandomColor(dimension.depth - 1)

	frame.setPixel(8, 1, dotcolor)
	frame.setPixel(9, 1, dotcolor)
	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):
		for y in range(5):
			if leftNumber[y][x] == 1:
				frame.setPixel(x+1, y+1, numcolor)
			if rightNumber[y][x] == 1:
				frame.setPixel(x+12, y+1, numcolor)

	out.sendFrame(frame)
	if delay > 0:
		time.sleep(delay / 1000.0)



def main():
	print 'running a \'Bot vs. Bot\' round...'
	#out = blup.output.getOutput('blp:localhost:42421')
	#out = blup.output.getOutput('e3blp:bastel0:4242')
	out = blup.output.getOutput('e3blp:localhost:4242')
	#out = blup.output.getOutput('e3blp:bbunt:42429')
	#dim = blup.frame.FrameDimension(18, 8, 8, 3)
	dim = blup.frame.FrameDimension(22, 16, 255, 3)

	playground = Playground(22, 16, paddlesize=4)
	pp = PlaygroundPainter(out, dim, playground)

	leftPaddle = playground.leftPaddle
	rightPaddle = playground.rightPaddle
	ball = playground.ball

	leftBot = PongBot(playground, leftPaddle, 1)
	rightBot = PongBot(playground, rightPaddle, 1)

	print playground.play()


if __name__ == '__main__':
	main()