Python network.poll函数代码示例

    def send_network(self, cmd):
        self.cmds = ['up', 'down', 'left', 'right']
        poll()
        if cmd in self.cmds:

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

    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)

 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)

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

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

 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)

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

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:

            # 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()

        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")

    
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))

def periodic_poll():
    while 1:
        poll()
        sleep(0.05)

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

 def update(self):
     poll(0.01)

""" 
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