Question

I’m running a pygames program with twisted and I’m having problems when it comes to sending data from within a pygame event.

First here is the server:

from twisted.internet.protocol import Factory
from twisted.protocols.basic import LineReceiver
from twisted.internet import reactor
import simplejson

class Game_Data(LineReceiver):
    def __init__(self, players, clients):
        self.players = players
        self.clients = clients

## the connectionMade method of LineReceiver is being used to create ##
## protocol instances of each client so it can send back any data it gets ##

    def connectionMade(self):
        new_player = 'player_' + str(len(self.players) + 1)
        self.clients.append(self)
        self.players.append(new_player)
        self.players = simplejson.dumps(self.players)
        for client in self.clients:
            client.sendLine(self.players)

## what ever data the server receives it sends right back to any clients ##

    def lineReceived(self,line):
        self.line = line
        print self.line
        for client in self.clients:
            client.sendLine(self.line)


class BlackFactory(Factory):
    def __init__(self):
        self.players = []
        self.clients = []

    def buildProtocol(self, addr):
        return Game_Data(self.players, self.clients)


reactor.listenTCP(6000, BlackFactory())

Now for the client:

import pygame
from twisted.internet.protocol import Protocol, ClientFactory
from twisted.protocols.basic import LineReceiver
from twisted.internet.task import LoopingCall
from twisted.internet import reactor

class BlackClientProtocol(LineReceiver):
    def __init__(self, recv, host):
        self.recv = recv
        self.host = host

    def lineReceived(self, line):
        self.recv(line)
        print line ## prints out as expected ##

    def connectionMade(self):
        self.host = self
        print self.host ## prints out as expected ##

class BlackClient(ClientFactory):
    def __init__(self, recv, host):
        self.recv = recv
        self.host = host

    def buildProtocol(self, addr):
        return BlackClientProtocol(self.recv, self.host)

class Client(object):
    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode((800, 600))
        pygame.display.flip()
        reactor.callLater(0.1, self.tick)

    def new_line(self, line):
        self.line = line

## this trial_func was to see if I could pass the BlackClient another argument ##
## to return an instance of the protocol to be called later in this class ##     

    def trial_func(self, host):
        self.host = host

    def tick(self):
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                print self.line  ## prints out as expected##
                print self.host  ## does not print out ???##


if __name__ == '__main__':
    c = Client()
    lc = LoopingCall(c.tick)
    lc.start(0.1)
    reactor.connectTCP('192.168.1.2', 6000, BlackClient(c.new_line, c.trial))
    reactor.run()

Edit: This is a more explicit example of whats going on. With the comments being the hang-ups. As long as you have pygames installed this will run, with the pygame event being a simple KEYDOWN (escape key) event as the trigger for the client to send data.

Answer 1

I looked at your code and this seems to be the relevant part:

def tick(self):
    flag = 0
    for event in pygame.event.get():
    ...
## call an instance of the protocol and sendLine ##
                    BlackClient(self.new_line(allhands)) ## this line does not work ##
## send allhands data ##
    ...

You want so send data back to the server, but here you’re just creating a new instance of BlackClient.

You probably want to use sendLine to send the line, but you need a reference to the current protocoll instance (or at least to this method).

---

This is an example how you could achieve this:

class Client(object):
    ...
    # this method is going to be replaced
    def sendLine(self, line):
        pass

    def tick(self):
        flag = 0
        for event in pygame.event.get():
            ...
            ## call sendLine, which is replaced by the sendLine method from the protocol ##
            self.sendLine(yourStuff)        

class BlackClient(ClientFactory):
    def __init__(self, client):
        # keep instance of client
        self.client = client

    def buildProtocol(self, addr):
        # give client.new_line method to protocol
        proto = BlackClientProtocol(self.client.new_line)
        # replace client's sendLine with proto.sendLine
        self.client.sendLine = proto.sendLine
        return proto

if __name__ == '__main__':
    c = Client()
    lc = LoopingCall(c.tick)
    lc.start(0.1)
    protocoll = 
    reactor.connectTCP('192.168.1.2', 6000, BlackClient(c))
    reactor.run()

This is just an example; you could probably clean up the code a bit. Maybe you want to use some kind of dispatcher (like pydispatch)