使用 udp 的 python 客户端游戏崩溃和滞后

如何解决使用 udp 的 python 客户端游戏崩溃和滞后

我正在尝试制作一个具有多个大厅作为进程的 python udp 游戏服务器

这是服务器的代码：

import socket
import multiprocess
 
def new_lobby(port,addr1,addr2):
    import socket
    import Queue
    import threading
    address1 = addr1
    address2 = addr2
    local_ip = ""
    local_port = port
    buffer_size = 1024
    print(port)
    sock = socket.socket(family = socket.AF_INET,type = socket.soCK_DGRAM)
    sock.bind((local_ip,local_port))
    sock.settimeout(10)
    running  = True
    q = Queue.Queue(10000)
    print ("before threads")
 
    def listen(sock):
        running = True
        buffer_size = 1024
        while running:
            try:
                data_address = sock.recvfrom(buffer_size)
            except socket.timeout:
                running = False
            q.put(data_address)
    def send(sock,address1,address2):
        while True:
            data_address = q.get()
            if data_address[1] == address1:
                sock.sendto(data_address[0],address2)
            else:
                sock.sendto(data_address[0],address1)
    thread1 = threading.Thread(target = listen,args=(sock,))
    thread2 = threading.Thread(target = send,args = (sock,address2))
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
 
 
local_ip = ""
local_port = 10001
buffer_size = 1024
 
server_message = "connected"
byte_server_message = str.encode(server_message)
 
sock = socket.socket(family = socket.AF_INET,type = socket.soCK_DGRAM)
 
sock.bind((local_ip,local_port))
 
lobby = []
 
port_count = 10002
 
check_alive = False
 
while True:
    message,address = sock.recvfrom(buffer_size)
    message = message.decode("utf-8")
    print(address," ",message)
    if address not in lobby:
        lobby.append(address)
    if len(lobby) == 2:
        p = multiprocess.Process(target = new_lobby,args = (port_count,lobby[0],lobby[1]))
        p.start()
        port = str(port_count)
        port = port.encode()
        for address in lobby:
            print(address)
            sock.sendto(port,address)
        port_count += 1
        lobby = []
        check_alive = True
    if check_alive:
        print(p.is_alive())
 

这是我制作的测试客户端的代码：

import pygame
import socket
import json
import queue
import threading
import sys
#f = find lobby
pygame.init()
 
class Connection():
    def __init__(self):
        self.msgFromClient = "f"
        self.bytesToSend         = str.encode(self.msgFromClient)
        self.serverAddressport   = ("",10001)
        self.bufferSize          = 10000
        self.sock = socket.socket(family=socket.AF_INET,type=socket.soCK_DGRAM)
        self.sock.sendto(self.bytesToSend,self.serverAddressport)
        self.msgFromServer = self.sock.recvfrom(self.bufferSize) 
        self.msg = self.msgFromServer[0]
        self.port = self.msg.decode("utf-8")
        self.port = int(self.port)
        self.serverAddressport   = ("",self.port)
        self.q_listen = queue.Queue(1000)
        self.q_send = queue.Queue(1000)
        def listen(sock,buffer_size):
            running = True
            while running:
                data_address = sock.recvfrom(buffer_size)
                data = data_address[0].decode("utf-8")
                data = json.loads(data)
                self.q_listen.put(data)
        def send(sock,serverAddressport):
            running = True
            while running:
                data = self.q_send.get()
                if data:
                    data = json.dumps(data)
                    data = bytes(data,'utf-8')
                    sock.sendto(data,serverAddressport)
 
        sock = self.sock
        buffer_size = self.bufferSize
        serverAddressport = self.serverAddressport
        self.thread = threading.Thread(target = listen,buffer_size,))
        self.thread2 = threading.Thread(target = send,serverAddressport))
        self.thread.daemon = True
        self.thread2.daemon = True
        self.thread.start()
        self.thread2.start()
 
 
 
import global_variables as g
 
#de sters,o sa fie initializat in main game
g.screen = pygame.display.set_mode([1800,900])
 
class Player(pygame.sprite.Sprite):
    def __init__(self,color):
        pygame.sprite.Sprite.__init__(self)
        self.size = 60
        self.image = pygame.Surface((self.size,self.size))
        self.image.fill(color)
        self.rect = self.image.get_rect()
        self.rect.center = (400,400)
 
    def Blit(self,screen):
        screen.blit(self.image,self.rect)
 
class Test_Game():
    def __init__(self):
        g.variables_initialization()
        self.surface_size = g.surface_size
        self.surface = pygame.Surface((self.surface_size,self.surface_size))
        self.surface_rect = self.surface.get_rect()
        self.surface_rect.center = (800,450)
        self.running = True
 
        self.player = Player(g.brown)
        self.player2 = Player(g.green)
        self.connection = Connection()
    
    def Blit_Images(self):
        g.screen.fill(g.white)
        self.surface.fill(g.black)
        self.player.Blit(self.surface)
        self.player2.Blit(self.surface)
        g.screen.blit(self.surface,self.surface_rect)
        pygame.display.flip()
    
    def Update(self):
        dt = g.clock.tick(60) / 1000
        pos = pygame.mouse.get_pos()
        self.player.rect.centerx = pos[0] - 400
        self.player.rect.centery = pos[1] - 50
        coord = (self.player.rect.centerx,self.player.rect.centery)
        self.connection.q_send.put(coord)
        self.player2.rect.center = self.connection.q_listen.get()
        
            
    
    def Check_Events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            
    def Loop(self):
        while self.running == True:
            self.Check_Events()
            self.Update()
            self.Blit_Images()
 
 
test_game = Test_Game()
test_game.Loop()

还有一个全局变量文件：

import pygame
def variables_initialization():
    global clock
    global dt
    global screen
    global surface_size
    global white
    global black
    global green
    global brown
    global gray
    clock = pygame.time.Clock()
    dt = 0
    surface_size = 800
    white = (250,250,250)
    black = (0,0)
    green = (115,198,0)
    brown = (102,51,0)
    gray = (215,218,218)

一段时间后，客户端变得迟钝并冻结。我不知道如何解决这个问题。 这是第一个项目，所以我将不胜感激任何建议。