Exemple #1
0
 def trySend(self, s):
     try:
         self.conn.sendall(s)
     except:
         utils.printConn("Client lost conn, trySend")
         playermanager.removePlayer(self.player)
         sys.exit()
Exemple #2
0
    def run(self):
        global playermanager
        global maplvl

        #send the map
        self.conn.send(str(maplvl))
        
        while 1:
            time.sleep(0.25)
            
            #send player id/positions
            try:
                self.conn.sendall(pickle.dumps((self.runState,playermanager.packBig())))
                self.runState = -1
            except:
                utils.printConn("Observer disconnected")
                return
Exemple #3
0
    def modeMain(self):
        global playermanager
        global moveevent
        global moveevent2
        
        #if we are not supposed to be playing
        if not self.runState == constant_class.game_main:
            return

        self.player.isPlaying = True

        #stay in this mode as long as we are alive
        while self.runState == constant_class.game_main:
            #send (playerdata,localplayers)
            self.trySend(pickle.dumps((constant_class.packet_main,(self.player.packSmall(),playermanager.packLocal(self.player)))))
            
            #we should be reciving a direction
            try:
                self.data = int(self.conn.recv(1024)[0])
            except:
                #if we recved nothing then int will fail
                utils.printConn("Client lost conn, main mode")
                playermanager.removePlayer(self.player)
                self.conn.close()
                sys.exit()
                
            #if the client had an error assume they aren't going to move
            if self.data == constant_class.packet_err:
                self.data = 4

            #wait for second move flag
            moveevent2.wait()

            #set the next direction
            self.player.nextdir = self.data

            #wait for move flag
            moveevent.wait()
            
            #check for player death
            if self.player.isDead():
                self.runState = constant_class.game_wait
                self.player.isPlaying = False
Exemple #4
0
    def modeHeartbeat(self):
        global heartbeatDelay

        #if we are not supposed to be waiting
        if not self.runState == constant_class.game_wait:
            return
        
        self.player.isPlaying = False        
        while self.runState == constant_class.game_wait:
            #send a heart beat
            self.trySend(pickle.dumps((constant_class.packet_heartbeat, heartbeatDelay)))
        
            try:
                pk_code = int(self.conn.recv(1024)[0])
            except:
                utils.printConn("Client lost conn, heartbeat")
                playermanager.removePlayer(self.player)
                sys.exit()
            
            #wait until next heartbeat
            time.sleep(heartbeatDelay)
Exemple #5
0
    #create a client
    client = client_class(map, sock)

    #main loop
    while 1:
        #recieve and process packet
        receved = False

        try:
            (pk_code, data) = pickle.loads(utils.getDataFromSocket(sock))
            receved = True
        except:
            pass

        if receved:            
            #these modes process the data and respond to the server accordingly
            if pk_code == constant_class.packet_main:
                client.modeMain(data)
            elif pk_code == constant_class.packet_heartbeat:
                client.modeHeartbeat(data)
            elif pk_code == constant_class.packet_spawn:
                client.modeSpawn(data)
        else:
            try:
                sock.send(str(constant_class.packet_err))
            except:
                utils.printConn("Lost connection to server!")
                sys.exit()
    sock.close()
Exemple #6
0
    ogui = ObserverGUI()
    
    #main loop
    time = 0
    code = -1
    running = True
    while running:

        #recv player id/position
        try: 
            data = utils.getDataFromSocket(s)
            (code, data) = pickle.loads(data)
            if not data == None:
                playermanager.loadBig(data)
        except: 
            utils.printConn('Couldnt load round of player data.')
    
        if code == constant_class.game_spawn:
            mapscene.reset()
        
        # Update all the players on the map
        # This will add players if they havent been added
        players = playermanager.getPlayerList()
        #print len(players)
        for player in players:
            mapscene.updatePlayer(player)
            
        # Update the GUI
        if len(players) > 0:
            ogui.update(players)
            ogui.updatePlayerStats(players)