blup/balancep0ng.py

#!/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)