python - 检测TCP何时拥塞python twisted socket服务器

我正在做一个实时的MMO游戏，并有一个工作的TCP服务器（连同游戏客户端），但现在我正在考虑使用UDP不断更新其他玩家的位置（以大大减少随机游戏填充器从TCP拥塞控制！）
我希望在这方面能得到比我聪明的人的帮助（我是python/twisted新手，在其他地方找不到这个信息；）
目前，我的服务器接受一个简单的twisted协议连接。如。

''' TCP reciever '''
class TCPProtocol(Protocol):

    def connectionMade(self):
        #add to list of connected clients
        factory.clients.append(self)

    def dataReceived(self, data):
        pass


#setup factory and TCP protocol class
factory = Factory()
factory.protocol = TCPProtocol
factory.clients = []
reactor.listenTCP(1959, factory)

@@@@@@@@@@@@@@更新@@@@@@@@@@@@@@：
如何分别对每个协议实例执行拥塞检查？请在下面的代码示例中用一些东西开始我的工作：（这里写的是“help here please！”）
我想得不对吗？任何指导都太棒了，谢谢！

from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor

KServerIP='127.0.0.1'
KServerPortTCP=8000
#KClientPortUDP=7055

''' TCP reciever '''
class TCPProtocol(Protocol):

    def connectionMade(self):
        #add to list of connected clients
        factory.clients.append(self)

        #set client variables (simplified)
        self.pos_x=100
        self.pos_y=100

        #add to game room (to recieve updates)
        mainGameRoom.clientsInRoom.append(self)

    def dataReceived(self, data):
        pass

    #send custom byte message to client (I have special class to read it)
    def sendMessageToClient(self, message, isUpdate):

''' @@@@@@@@@@@@@@@@@  HELP HERE PLEASE!  @@@@@@@@@@@
        if isUpdate and (CHECK IF CLIENT IS CONGESTED??? )
            return  (and send next update when not congested)'''
     '''@@@@@@@@@@@@@@@@@  HELP HERE PLEASE!  @@@@@@@@@@@   '''

        #if not congested, write update!
        msgLen = pack('!I', len(message.data))
        self.transport.write(msgLen) #add length before message
        self.transport.write(message.data)

#simplified version of my game room
#this room runs the game, and clients recieve pos updates for
#everyone in this room (up to 50 people)
dt_gameloop=1.0/60 #loop time difference
dt_sendClientUpdate=0.1 #update intervar
class GameRoom(object):
    #room constants
    room_w=1000
    room_h=1000

    def __init__(self):
        super(GameRoom, self).__init__()
        #schedule main game loop
        l=task.LoopingCall(self.gameLoop)
        l.start(dt_gameloop) # call every X seconds
        #schedule users update loop
        l=task.LoopingCall(self.sendAllClientsPosUpdate)
        l.start(dt_sendClientUpdate) # call every X seconds

    def gameLoop(self):
        #game logic runs here (60 times a second),  EG.
        for anUpdateClient in self.clientsInRoom:
            anUpdateClient.pos_x+=10
            anUpdateClient.pos_y+=10

    #send position update every 0.1 seconds,
    #send all player positions to all clients
    def sendAllClientsPosUpdate(self):

        message = MessageWriter()
        message.writeByte(MessageGameLoopUpdate) #message type

        #create one byte message containing info for all players
        message.writeInt(len(self.clientsInRoom)) #num items to read
        for aClient in self.clientsInRoom:
            message.writeInt(aClient.ID)
            message.writeFloat( aCell.pos_x )#pos
            message.writeFloat( aCell.pos_y )

        #send message to all clients
        for aClient in self.clientsInRoom:
            aClient.sendMessageToClient(message, True)

#setup factory and TCP protocol class
factory = Factory()
factory.protocol = TCPProtocol
factory.clients = []
reactor.listenTCP(KServerPortTCP, factory)

#simple example, one game room
mainGameRoom=GameRoom()


print "Server started..."
reactor.run()

最佳答案

You probably don't need UDP (yet)
你说的第一件事是你想“减少网络拥塞…从TCP”。这不是UDP所做的。UDP允许您绕过拥塞控制，这实际上会增加网络拥塞。在您了解如何实现自己的拥塞控制算法之前，高延迟连接上的UDP流量只会导致数据包风暴，淹没您的服务器并淹没用户的网络连接，使它们不可用。
在实时游戏中发送移动包的重要一点是，当一个新的位置已经可用时，你总是想确保你不会浪费时间“赶上”旧的移动包。在Twisted中，您可以使用producer and consumer APIs在TCP连接上很好地执行此操作，如下所示：

from zope.interface import implementer
from twisted.internet.protocol import Protocol
from twisted.internet.interfaces import IPullProducer

def serializePosition(position):
    "... take a 'position', return some bytes ..."

@implementer(IPullProducer)
class MovementUpdater(Protocol, object):
    def updatePosition(self, newPosition):
        if newPosition != self.currentPosition:
            self.currentPosition = newPosition
            self.needToSendPosition()

    waitingToSend = False

    def needToSendPosition(self):
        if not self.waitingToSend:
            self.waitingToSend = True
            self.transport.registerProducer(self, False)

    def resumeProducing(self):
        self.transport.write(serializePosition(self.currentPosition))
        self.transport.unregisterProducer()
        self.waitingToSend = False

    def stopProducing(self):
        "nothing to do here"

每当游戏需要发送一个新位置时，它可以调用updatePosition来更新玩家的当前位置。updatePosition首先更新当前位置，然后调用needToSendPosition将连接标记为需要发送位置更新。这会将协议注册为其传输的生产者，这将导致每次写入缓冲区空间可用时调用resumeProducing。只要调用resumeProducing我们就发送最新位置的任何信息-如果在网络拥塞时调用updatePosition500次，那么一旦拥塞缓解，只发送一次更新。
这有点过于简单，因为每个transport一次只能有一个producer，而且您的游戏服务器可能有很多不同的位置更新要发送给客户端，所以您需要一个多路复用器，它聚合来自多个客户端的所有位置更新，还需要一些代码来命令r消息，以便除位置更新外的其他内容仍能通过，但该位置更新具有优先权。
如果你无论如何都要做UDP，这可能看起来像是额外的工作，但是如果你要正确地做UDP，并从中获得任何好处，你无论如何都需要实现类似的东西，所以这不会被浪费。