Пример #1
0
    def send_network(self, cmd):
        self.cmds = ['up', 'down', 'left', 'right']
        poll()
        if cmd in self.cmds:

            msg = cmd
            self.do_send({'input' : msg})
Пример #2
0
 def fetch_game_state(self):
     args = {'name': game.myname}  # TODO: bad: out-of-band info
     # need a hypermedia form instead
     self.enqueue_request('GET', '/game/1', args, self._callback_game)
     while len(
             self._request_queue) > 0 or self._pending_rsrc_req is not None:
         poll(timeout=0.1)
Пример #3
0
    def poll(self):

        poll()

        p = self.m.pellets[0]  # always target the first pellet
        b = self.m.mybox
        if p[0] > b[0]:
            cmd = 'right'
        elif p[0] < b[0]: # p[2] to avoid stuttering left-right movement
            cmd = 'left'
        elif p[1] > b[1]:
            cmd = 'down'
        else:
            cmd = 'up'
        self.m.do_cmd(cmd)
Пример #4
0
 def poll(self):
    poll() 
    if len(self.m.players) > 0:
       p = self.m.pellets[0]  # always target the first pellet
       b = self.m.mybox
       if p[0] > b[0]:
           cmd = 'right'
       elif p[0] + p[2] < b[0]: # p[2] to avoid stuttering left-right movement
           cmd = 'left'
       elif p[1] > b[1]:
           cmd = 'down'
       else:
           cmd = 'up'
       msg = {'input': cmd}
       self.m.do_send(msg)
Пример #5
0
def run():

    #while 1:
    
        # enqueue the player events received by the client handlers
        poll()
        
        '''checks what kind of event happened, then filters it so that it can send the correct
        event out to the clients.
    
        within the messages, the first part is the type of message(player joined, player quit
            player pushed a key, etc)
        the second part is the name of the player that did that event
        '''
        '''
        for event, handler in event_queue:
            if event == 'quit':
                msg = {'msg_type':'quit',
                       'their_name': players[handler].name(),
                       }
                del players[handler]
                broadcast(msg)
                
            elif event == 'join':
                player_name = generate_name()
                players[handler] = Player(player_name)
                msg = {'msg_type': 'join',
                       'their_name': players[handler].name(),
                       'players_list': players
                       }
                broadcast(msg)
            
            elif event == 'input':
                msg = {'msg_type': 'player_movement',
                         'their_name': players[handler].name(),
                         'input': event
                         }
                broadcast(msg)
        
            elif event == 'shot':
                msg = {'msg_type': 'player_shot',
                       'their_name': players[handler].name()
                      }
                broadcast(msg)
        '''
        event_queue = []
    
        sleep(1. / 20) # seconds
Пример #6
0
def run():
    #while 1:
        
        #msg = "" #message
        #if msg == 'quit' or msg == 'exit':
        #    client.do_close()
        #elif msg: # ignore empty strings
        #client.do_send({'myname': myname, 'input': msg})
            
        poll() # push and pull network messages

        #for m in event_queue:
        #process_input("")#m) 
        event_queue = []
        
        sleep(1. / 20) # seconds
Пример #7
0
def run():
    #while 1:

    #msg = "" #message
    #if msg == 'quit' or msg == 'exit':
    #    client.do_close()
    #elif msg: # ignore empty strings
    #client.do_send({'myname': myname, 'input': msg})

    poll()  # push and pull network messages

    #for m in event_queue:
    #process_input("")#m)
    event_queue = []

    sleep(1. / 20)  # seconds
Пример #8
0
def run():

    #while 1:

    # enqueue the player events received by the client handlers
    poll()
    '''checks what kind of event happened, then filters it so that it can send the correct
        event out to the clients.
    
        within the messages, the first part is the type of message(player joined, player quit
            player pushed a key, etc)
        the second part is the name of the player that did that event
        '''
    '''
        for event, handler in event_queue:
            if event == 'quit':
                msg = {'msg_type':'quit',
                       'their_name': players[handler].name(),
                       }
                del players[handler]
                broadcast(msg)
                
            elif event == 'join':
                player_name = generate_name()
                players[handler] = Player(player_name)
                msg = {'msg_type': 'join',
                       'their_name': players[handler].name(),
                       'players_list': players
                       }
                broadcast(msg)
            
            elif event == 'input':
                msg = {'msg_type': 'player_movement',
                         'their_name': players[handler].name(),
                         'input': event
                         }
                broadcast(msg)
        
            elif event == 'shot':
                msg = {'msg_type': 'player_shot',
                       'their_name': players[handler].name()
                      }
                broadcast(msg)
        '''
    event_queue = []

    sleep(1. / 20)  # seconds
Пример #9
0
    def poll(self):
        clock = Clock()

        poll()

        p = self.m.pellets[0]  # always target the first pellet
        b = self.m.mybox
        if p[0] > b[0]:
            cmd = 'right'
        elif p[0] + p[2] - 1< b[0]: # p[2] to avoid stuttering left-right movement
            cmd = 'left'
        elif p[1] > b[1]:
            cmd = 'down'
        else:
            cmd = 'up'

        msg = {'input': cmd}
        self.client.do_send(msg)

        # removes jittery movement
        clock.tick(30)
Пример #10
0
 def poll(self):
    poll() 
    if len(self.m.players) != 0:
       p = self.m.pellets[0]  # always target the first pellet
       b = self.m.players[self.m.players.keys()[0]]      
       if p[0] > b[0]:
           cmd = 'right'
           # print p
       elif p[0] + p[2] < b[0]:
           cmd = 'left'
       elif p[1] > b[1]:
           cmd = 'down'
           # print p
       elif p[1] == b[1]:
           cmd = 'left'
       elif p[0] == b[0]:
           cmd = 'right'
       else:
           cmd = 'up'
         
       msg = {'input': cmd}
       self.m.do_send(msg)
Пример #11
0
def periodic_poll():
    while 1:
        if not len(chatting) and len(connected_users):
            next_user = connected_users.values()[0]
            chatting[next_user.handler] = next_user
            print "user in room"
            
        elif len(chatting) == 1 and chatting.keys()[0] in connected_users and len(connected_agents):
            next_agent = connected_agents.values()[0]
            for person in chatting:
                    person.do_send({'join': next_agent.name})
            next_agent.handler.do_send({'speak': chatting.values()[0].name.upper(), 'txt': chatting.values()[0].topic.upper()})
            chatting[next_agent.handler] = next_agent
            print "agent joins user"
            
        elif len(chatting) == 1 and chatting.keys()[0] in connected_agents and len(connected_users):
            next_user = connected_users.values()[0]
            for person in chatting:
                    person.do_send({'join': next_user.name})
            chatting.keys()[0].do_send({'speak': next_user.name.upper(), 'txt': next_user.topic.upper()})
            chatting[next_user.handler] = next_user
            print "user joins agent"
        
        poll(timeout=0.05) # in seconds
Пример #12
0
def periodic_poll():
    while 1:
        poll(timeout=0.05)  # seconds
Пример #13
0
            handlers[self] = msg['join']
            userName = username + " Joined"
            for h in handlers:
                h.do_send(userName)
            for h in handlers:
                h.do_send('Users: ' + handlers[self])
        elif 'speak' in msg:
            for h in handlers :
                print h
                if h != msg['speak']:
                    h.do_send(msg['speak'] + ': ' + msg['txt'])
        elif 'close' in msg:
            self.on_close(self)
        
        print msg
       
        
        
        
    
class Serv(Listener):
    handlerClass = MyHandler


port = 8888
server = Serv(port)
while 1:
    poll()
    sleep(0.05)  # seconds

Пример #14
0
 def update(self):
     poll(0.01)
Пример #15
0

def sendGameStateToClients(gameState):
    for x in handlerList:
        handlerList[x].do_send(gameState)


port = 8888
server = Listener(port, MyHandler)

while True:
    windowSurfaceObj.fill(blackColor)

    pygame.draw.lines(windowSurfaceObj, greyColor, False, groundPoints)

    poll(timeout=0.05)

    for x in particleList:
        pygame.draw.rect(windowSurfaceObj, greyColor,
                         pygame.Rect(x.getPosX(), x.getPosY(), 2, 2))

    for x in landerList:
        landerList[x].update()
    for x in particleList:
        x.update()
        if x.queuedForRemoval():
            particleList.remove(x)
    landersToBeDestroyed = set()
    for x in landerList:
        for y in landerList:
            if landerList[x] != landerList[y]:
Пример #16
0
from network import Listener, Handler, poll


done = False

class MyHandler(Handler):
    
    def on_open(self):
        print 'srv on open'
        
    def on_close(self):
        print 'srv on close'
    
    def on_msg(self, data):
        print 'srv received %s' % str(data)
        msg = {12: 3, 'hello': (1, 2)}
        self.do_send(msg)
        print 'srv sent %s' % str(msg)
        self.close_when_done()
        global done
        done = True
    

port = 8888
server = Listener(port, MyHandler)
while not done:
    poll(timeout=.1)
server.stop()  # cleanup
Пример #17
0
 def poll(self):
     poll(0.05)
     self.do_send({'input':self.move()})
Пример #18
0
 def update(self):
     poll(0.01)
Пример #19
0
client = Client('localhost', 8888)

pygame_init()
screen = set_mode((400, 300))
clock = Clock()
font = Font(None, 15)  # default pygame Font, height in pixels

borders = [Rect(0, 0, 2, 300), Rect(0, 0, 400, 2),
           Rect(398, 0, 2, 300), Rect(0, 298, 400, 2)]
dx, dy = 0, 1  # start direction: down
delay = 0  # start moving right away 

while True:
    
    clock.tick(50)  # frames per second
    poll()  # push and pull network messages

    for event in pygame_event.get():  # inputs
        if event.type == QUIT:
            exit()
        if event.type == KEYDOWN:
            key = event.key
            if key == K_ESCAPE:
                exit()
            elif key == K_UP:
                dx, dy = 0, -1
            elif key == K_DOWN:
                dx, dy = 0, 1
            elif key == K_LEFT:
                dx, dy = -1, 0
            elif key == K_RIGHT:
Пример #20
0
 def serverLoop(self):
     while 1:
         poll(timeout=0.05)  # in seconds
Пример #21
0
""" 
Directory: Give the list of connected peers when asked for it.
Keep an up-to-date directory by receiving periodic heartbeats from the peers.
""" 

from network import Listener, Handler, poll


peers = set()

class MyHandler(Handler):
    
    def on_close(self):
        peers.remove(self)
        
    def on_msg(self, data):
        mtype = data['mtype']
        if mtype == 'join_dir':
            self.ip_port = data['ip_port']
            self.do_send({'mtype': 'welcome',
                          'others_ip_port': [p.ip_port for p in peers]})
            peers.add(self)
            

Listener(8888, MyHandler)

while 1:
    poll(timeout=.1)  # seconds
Пример #22
0
def beginGame():

    host, port = '192.168.0.3', 8888
    client = Client(host, port)

    has_lander = False
    game_over = False

    game_over_tick = 0

    while game_over_tick < 120:

        if game_over == True:
            game_over_tick += 1

        if should_exit == True:
            ##print('**** Disconnected from server ****')
            ##sys.exit()
            pass

        poll()

        windowSurfaceObj.fill(blackColor)

        pygame.draw.lines(windowSurfaceObj, greyColor, False, groundPoints)

        for x in particleList:
            pygame.draw.rect(windowSurfaceObj, greyColor,
                             pygame.Rect(x[0], x[1], 2, 2))

        for x in landerList:
            if x[7] != 'DESTROYED':
                windowSurfaceObj.blit(
                    pygame.transform.rotate(landerSurfaceObj, x[0]),
                    (x[1], x[2]))

        for x in landerList:
            try:
                if x[4] == client.getPlayerID():
                    has_lander = True
                    myLander = x
            except:
                pass

        if has_lander:
            if myLander[5] != '':
                game_over = True
                gameWinLoseText = gameFont.render(myLander[5], True, greyColor)

        if has_lander:
            landerPlayerIdentifierText = gameFont.render(
                'You', True, greyColor)
            windowSurfaceObj.blit(landerPlayerIdentifierText,
                                  (myLander[1], myLander[2] - 20))
            landerFuelText = gameFont.render(
                'Lander Y Velocity: ' + str(myLander[6]), True, greyColor)
            windowSurfaceObj.blit(landerFuelText, (400, 30))

        if game_over:
            windowSurfaceObj.blit(gameWinLoseText, (30, 30))

        if has_lander:
            landerFuelText = gameFont.render(
                'Lander Fuel: ' + str(myLander[3]), True, greyColor)
            windowSurfaceObj.blit(landerFuelText, (400, 50))

        userCommand = checkForKeyPress()

        sendCommandToServer(client, userCommand)

        pygame.display.update()
        fpsClock.tick(30)

    client.do_close()
Пример #23
0
def periodic_poll():
    while 1:
        poll(timeout=0.05)  # seconds
Пример #24
0
            # connect to the peers
            others_ip_port = data['others_ip_port']
            connect_to_peers(others_ip_port)
            # create pellets if I'm the only peer, fetch them otherwise
            if others_ip_port: # other peers have pellets data
                fetch_pellets()
            else:
                create_pellets()


#####################################################################

# Establish connection with the directory server.
dir_client = DirectoryClient(DIRECTORY_HOST, 8888)  # async connect
while not dir_client.connected:
    poll(timeout=.1)  # seconds
print 'Connected to the directory server.'

# Send the IP and port I will be listening to.
# Receive in response the list of (IP, port) of peers in the network.
dir_client.do_send({'mtype': 'join_dir', 
                    'ip_port': my_ip_port})
while not dir_client.directory_received:
    poll(timeout=.1)  # seconds
print 'Retrieved a directory of %d peers.' % len(peers)

# Listen to incoming P2P connections from future peers.
p2p_listener = Listener(my_port, Peer)


pygame.init()
Пример #25
0
 def poll_messages(self):
     poll()
     sleep(.02)
Пример #26
0
 def poll_messages(self):
     poll()
     sleep(.01)
Пример #27
0
def periodic_poll():
	while 1:
		poll()
		sleep(0.05)  # seconds
Пример #28
0
from network import Handler, poll

done = False


class Conn(Handler):
    def on_open(self):
        print 'cli on open'
        msg = [1, 2, 3]
        self.do_send(msg)
        print 'cli sent %s' % str(msg)

    def on_close(self):
        print 'cli on close'

    def on_msg(self, data):
        print 'cli received %s' % str(data)
        self.close_when_done()
        global done
        done = True


host, port = 'localhost', 8888
client = Conn(host, port)
while not done:
    poll(timeout=.1)
client.do_close()  # cleanup
Пример #29
0
    
def render(handler):
    # render game state into a surface. This rendering varies for each player.
    screen = pygame.Surface((WIDTH, HEIGHT))
    screen.fill((0, 0, 64))  # dark blue
    [pygame.draw.rect(screen, (0, 191, 255), b) for b in borders]  # deep sky blue 
    [pygame.draw.rect(screen, (255, 192, 203), p) for p in pellets]  # shrimp
    [pygame.draw.rect(screen, (255, 0, 0), p.box) for h, p in players.items() if h != handler]
    pygame.draw.rect(screen, (0, 191, 255), players[handler].box)
    return screen

   
while 1:
    loop_start = time.time()
    
    # enqueue the player events received by the client handlers
    apply_client_events()
    update_avatars()
    
    # render and send screenshot
    for h in players.keys():
        surface = render(h) 
        msg = pygame.image.tostring(surface, 'RGB') 
        h.do_send(msg)

    # poll until the tick is over
    while time.time() - loop_start < TICK_DURATION:
        poll(TICK_DURATION - (time.time() - loop_start))

Пример #30
0
                create_pellets()

    def connect_to_peers(self, ip_ports):
        for ip_port in ip_ports:
            ip, port = str(ip_port).split(':')
            peer = Peer(ip, int(port))
            peer.ip_port = ip_port
            peer.do_send({'mtype': 'join', 'ip_port': MY_IP_PORT})


# Send the IP and port I will be listening to.
# Receive in response the list of (IP, port) of peers in the network.
dir_client = DirectoryClient(DIRECTORY_HOST, 8888)  # async connect
dir_client.do_send({'mtype': 'join_dir', 'ip_port': MY_IP_PORT})
while not dir_client.directory_received:
    poll(timeout=.1)  # seconds
print 'Retrieved a directory of %d peers.' % len(peers)

# Listen to incoming P2P connections from future peers.
p2p_listener = Listener(MY_PORT, Peer)

################### loop ################

TICK_DURATION = 0.02  # seconds

while 1:
    loop_start = time.time()
    process_inputs()
    update_me()
    broadcast({'mtype': 'position', 'box': mybox})
    draw_everything()
Пример #31
0
client = Client('localhost', 8888)

pygame_init()
screen = set_mode((400, 300))
clock = Clock()
font = Font(None, 15)  # default pygame Font, height in pixels

borders = [Rect(0, 0, 2, 300), Rect(0, 0, 400, 2),
           Rect(398, 0, 2, 300), Rect(0, 298, 400, 2)]
dx, dy = 0, 1  # start direction: down
delay = 0  # start moving right away 

while True:
    
    clock.tick(50)  # frames per second
    poll()  # push and pull network messages

    for event in pygame_event.get():  # inputs
        if event.type == QUIT:
            exit()
        if event.type == KEYDOWN:
            key = event.key
            if key == K_ESCAPE:
                exit()
            elif key == K_UP:
                dx, dy = 0, -1
            elif key == K_DOWN:
                dx, dy = 0, 1
            elif key == K_LEFT:
                dx, dy = -1, 0
            elif key == K_RIGHT:
Пример #32
0
        self.do_send({'news': 'connected'})

    def on_close(self):
        del handlers[self]
        plyrs['n'] -= 1
        print("a client has disconnected")

    def on_msg(self, msg):
        if 'txt' in msg:
            if msg['txt'] == 'rdy':
                self.do_send({'num_rdy': plyrs['n']})
            elif msg['txt'] == 'lesgo':
                if self not in lesgo:
                    lesgo[self] = None
                if self in lesgo:
                    pass
                if len(lesgo) == 2:
                    broadcast({'news': 'START'})
        elif 'crt' in msg:
            all_scores[self] = msg['crt']
            evryscr = []
            broadcast({'top_score': str(find_top_score())})
            for player in all_scores:
                evryscr.append(all_scores[player])
            broadcast({'evryscr': evryscr})


Listener(8888, MyHandler)
while 1:
    poll(0.05)
Пример #33
0
 def loop(self):
     port = 8888
     s = Listener(port, MyHandler)
     while 1:
         poll(timeout=0.05) # in seconds
Пример #34
0
            if '#' in txt or '@' in txt:
                word_list = txt.split(" ")
                send_list = []
                for word in word_list:
                    if '#' in word:
                        pub = word.replace("#", "")
                        temp = subs.get(pub)
                        if temp != None:
                            for h in temp:
                                if h not in send_list:
                                    send_list.append(h)
                    #Private Publish
                    if '@' in word:
                        privpub = word.replace("@", "")
                        if names.has_key(privpub):
                            privhandler = names[privpub]
                            if privhandler not in send_list:
                                send_list.append(privhandler)
                if send_list != None:
                    for h in send_list:
                        h.do_send({'speak': name, 'txt' : txt})
        
            #No topic in msg
            if "#" not in txt and "+" not in txt and "-" not in txt and "@" not in txt and txt != "":
                broadcast({'speak': name, 'txt': txt})


Listener(8888, MyHandler)
while 1:
    poll(0.05)
Пример #35
0
def beginGame():

    host, port = '169.234.87.121', 8888
    client = Client(host, port)

    has_lander = False
    game_over = False

    game_over_tick = 0


    while game_over_tick < 120:

        if game_over == True:
            game_over_tick += 1
            
        if should_exit == True:
            ##print('**** Disconnected from server ****')
            ##sys.exit()
            pass

        poll()
        
        windowSurfaceObj.fill(blackColor)


        pygame.draw.lines(windowSurfaceObj, greyColor, False, groundPoints)
        
        for x in particleList:
            pygame.draw.rect(windowSurfaceObj, greyColor, pygame.Rect(x[0], x[1], 2, 2))

        
        for x in landerList:
            if x[7] != 'DESTROYED':
                windowSurfaceObj.blit(pygame.transform.rotate(landerSurfaceObj, x[0]), (x[1], x[2]))

        for x in landerList:
            try:
                if x[4] == client.getPlayerID():
                    has_lander = True
                    myLander = x
            except:
                pass

        if has_lander:
                if myLander[5] != '':
                    game_over = True
                    gameWinLoseText = gameFont.render(myLander[5], True, greyColor)

        if has_lander:
            landerPlayerIdentifierText = gameFont.render('You', True, greyColor)
            windowSurfaceObj.blit(landerPlayerIdentifierText, (myLander[1], myLander[2] - 20))
            landerFuelText = gameFont.render('Lander Y Velocity: ' + str(myLander[6]), True, greyColor)
            windowSurfaceObj.blit(landerFuelText, (400, 30))

        if game_over:
            windowSurfaceObj.blit(gameWinLoseText, (30, 30))

        if has_lander:
            landerFuelText = gameFont.render('Lander Fuel: ' + str(myLander[3]), True, greyColor)
            windowSurfaceObj.blit(landerFuelText, (400, 50))

        userCommand = checkForKeyPress()

        sendCommandToServer(client, userCommand)

        
        pygame.display.update()
        fpsClock.tick(30)

    client.do_close()
Пример #36
0
            # Leaving the room
            if msg['txt'] == "quit":
                self.do_close()
                # tell the others he left
                message = {'left':msg['speak'], 'users' : self._get_all_users()}

            else:
                message = msg # send it back
    
        if message != "":
            self._send_to_all_users(message)
        #print msg


    def _send_to_all_users(self,msg):
        for h in handlers:
            h.do_send(msg)

    def _get_all_users(self):
        users = ""
        for h in handlers:
            users = handlers[h] if users == "" else users +","+handlers[h]
        return users
 


port = 8888
server = Listener(port, MyHandler)
while 1:
    poll(timeout=0.05) # in seconds
Пример #37
0
                'size': [w, h]
            })

        elif msgtype == 'eat_player':  # grow the big by the size of the small
            small = players[data['target']]
            players[self.myname][2] += small[2]
            players[self.myname][3] += small[3]
            broadcast({
                'msg_type':
                'grow',
                'name':
                self.myname,
                'size': [players[self.myname][2], players[self.myname][3]]
            })

        elif msgtype == 'die':  # back to normal size and place me randomly
            players[self.myname] = [randint(0, 280), randint(0, 280), 10, 10]
            broadcast({
                'msg_type': 'die',
                'name': self.myname,
                'state': players[self.myname]
            })


server = Listener(8888, MyHandler)

# loop
while 1:
    poll()
    sleep(.05)  # seconds
Пример #38
0

def sendGameStateToClients(gameState):
    for x in handlerList:
        handlerList[x].do_send(gameState)

port = 8888
server = Listener(port, MyHandler)

while True:
    windowSurfaceObj.fill(blackColor)


    pygame.draw.lines(windowSurfaceObj, greyColor, False, groundPoints)

    poll(timeout=0.05)

    for x in particleList:
        pygame.draw.rect(windowSurfaceObj, greyColor, pygame.Rect(x.getPosX(), x.getPosY(), 2, 2))


    




    
    for x in landerList:
        landerList[x].update()
    for x in particleList:
        x.update()
Пример #39
0
 def periodic_poll(self):
     while 1:
         poll()
         sleep(0.05)  # seconds
    def on_close(self):
        for name, h in handlers.items():
            if h == self:
                del handlers[name]
        user = waiting.popleft()
        handlers[user[0]] = user[1]
        user[1].do_send(prompt)

    def on_msg(self, msg):
        if 'join' in msg:
            if len(handlers) >= 2:
                waiting.append((msg['join'], self))
                self.do_send("Please wait for next available agent")
            else:
                handlers[msg['join']] = self
                self.do_send(prompt)
        else:
            if (msg['speak'], self) in waiting:
                self.do_send("Please wait for next available agent")
            else:
                for name in handlers.keys():
                    if name != msg['speak']:
                        handlers[name].do_send(msg['speak'] + ": " +
                                               msg['txt'])


port = 8888
server = Listener(port, MyHandler)
while 1:
    poll(timeout=0.05)  # in seconds
Пример #41
0
 def serverLoop(self):
     while 1:
         poll(timeout=0.05) # in seconds
Пример #42
0
def periodic_poll():
    while 1:
        poll()
        sleep(0.05)
Пример #43
0
        print "SERVER ON_ACCEPT"
        print msg
        print self

class MyListener(Listener):
    def on_accept(self, h):
        print "MYLISTENER CLASS ON_ACCEPT"
        print h
        print self

def parseUser(msg):
    #print "MSG: " + msg
    if msg.find('join') != -1:
        strArr = msg.split("'")
        return strArr[3]
    else:
        return "%$$--#"
#------MODEL------
handlers = {}  # map client handler to user name
port = 7577
server = MyListener(port, MyHandler)    

#------CONTROLLER------
try:
    while 1:
        poll(timeout=0.1)
except KeyboardInterrupt:
    print "CLOSING"
    handlers["Admin"].do_send("ADMIN IS CLOSING")
    currentCustomer.do_send("ADMIN IS CLOSING")
Пример #44
0
    def on_msg(self, msg):
        surface = pygame.image.fromstring(msg, (WIDTH, HEIGHT), 'RGB')
        screen.blit(surface, (0, 0, WIDTH, HEIGHT))


client = Client('localhost', 8888)  # connect asynchronously

valid_inputs = {K_UP: 'up', K_DOWN: 'down', K_LEFT: 'left', K_RIGHT: 'right'}

while 1:
    loop_start = time.time()

    # send valid inputs to the server
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()
        if event.type == KEYDOWN:
            key = event.key
            if key == K_ESCAPE:
                exit()
            elif key in valid_inputs:
                msg = {'input': valid_inputs[key]}
                client.do_send(msg)

    # poll until tick is over
    while time.time() - loop_start < TICK_DURATION:
        poll(TICK_DURATION - (time.time() - loop_start))

    pygame.display.update()
Пример #45
0
        request = (method, resource, req_args, callback)
        self._request_queue.append(request)
        self._send_next_request()

    def fetch_game_state(self):
        args = {'name': game.myname}  # TODO: bad: out-of-band info
        # need a hypermedia form instead
        self.enqueue_request('GET', '/game/1', args, self._callback_game)
        while len(
                self._request_queue) > 0 or self._pending_rsrc_req is not None:
            poll(timeout=0.1)


client = Client('localhost', 8888)  # connect asynchronously
while not client.connected:  # poll until connected
    poll(timeout=0.1)

############## inputs ############
# TODO: this mapping was obtained out of band
valid_inputs = {K_UP: 'up', K_DOWN: 'down', K_LEFT: 'left', K_RIGHT: 'right'}


def process_inputs():
    # send valid inputs to the server
    for event in pygame.event.get():
        if event.type == QUIT:
            exit()
        if event.type == KEYDOWN:
            key = event.key
            if key == K_ESCAPE:
                exit()