def connect(self) -> None: # Handle connections and terminations self.manager = QueuedConnectionManager() # Wait for clients connection requests self.listener = QueuedConnectionListener(self.manager, 0) # Buffers incoming data from active connection self.reader = QueuedConnectionReader(self.manager, 0) # Transmit PyDatagrams to active connection self.writer = ConnectionWriter(self.manager, 0) # Open TCP Rendezvous to accept client connections with a limit self.socket = self.manager.openTCPServerRendezvous( self.port, self.backlog) self.listener.addConnection(self.socket) print("Server listening on port %s...." % str(self.port)) # Listen for mew incoming connections taskMgr.add(self.handle_incoming_connections, "Poll the connection listener", -39) # Listen for new datagrams taskMgr.add(self.handle_connection_data, "Poll the connection reader", -40) # Listen for dropped connections taskMgr.add(self.handle_dropped_connections, "Poll the dropped connection listener", -41) # See if game can be started taskMgr.add(self.start_game, "Start Game", -42)
def _initListener (self): """ Initializes this NetworkHost's connection listener. """ self._connListener = QueuedConnectionListener(self._connManager, 0) self._tcpSocket = connManager.openTCPServerRendezvous(self._portAddress, self._backlog) self._connListener.addConnection(self._tcpSocket)
def start(self, reader_cb, connection_cb): AbsNetwork.start(self, reader_cb) self.connection_cb = connection_cb self.c_listener = QueuedConnectionListener(self.c_mgr, 0) self.connections = [] self.tcp_socket = self.c_mgr.open_TCP_server_rendezvous(9099, 1000) self.c_listener.add_connection(self.tcp_socket) self.listener_tsk = eng.add_tsk(self.tsk_listener, -39) eng.log_mgr.log('the server is up')
def setupTCP(self): self.tcpManager = QueuedConnectionManager() self.tcpReader = QueuedConnectionReader(self.tcpManager, 0) self.tcpWriter = ConnectionWriter(self.tcpManager, 0) self.tcpListener = QueuedConnectionListener(self.tcpManager, 0) self.tcpSocket = self.tcpManager.openTCPServerRendezvous(self.tcpport, self.backlog) self.tcpListener.addConnection(self.tcpSocket) print ("Started Server on: ", self.hostname, self.tcpport)
def __init__(self): self.c_manager = QueuedConnectionManager() self.c_listener = QueuedConnectionListener(self.c_manager, 0) self.c_reader = QueuedConnectionReader(self.c_manager, 0) self.c_writer = ConnectionWriter(self.c_manager,0) self.active_conns=[] self.port_address=9099 #No-other TCP/IP services are using this port self.backlog=1000 #If we ignore 1,000 connection attempts, something is wrong!
def setupTCP(self): self.tcpManager = QueuedConnectionManager() self.tcpReader = QueuedConnectionReader(self.tcpManager, 0) self.tcpWriter = ConnectionWriter(self.tcpManager, 0) self.tcpListener = QueuedConnectionListener(self.tcpManager, 0) self.tcpSocket = self.tcpManager.openTCPServerRendezvous( self.config.TCPPORT, self.config.BACKLOG) self.tcpListener.addConnection(self.tcpSocket) print("Started Server on: ", self.config.HOSTNAME, self.config.TCPPORT)
class Network(): def __init__(self): self.c_manager = QueuedConnectionManager() self.c_listener = QueuedConnectionListener(self.c_manager, 0) self.c_reader = QueuedConnectionReader(self.c_manager, 0) self.c_writer = ConnectionWriter(self.c_manager,0) self.active_conns=[] self.port_address=9099 #No-other TCP/IP services are using this port self.backlog=1000 #If we ignore 1,000 connection attempts, something is wrong! #tcp_socket = c_manager.openTCPServerRendezvous(port_address,backlog) #self.tcp_socket = self.c_manager.openTCPServerRendezvous("0.0.0.0", 9099, 1000) #self.c_listener.addConnection(self.tcp_socket) def tsk_listener_pol(self, taskdata): if self.c_listener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.c_listener.getNewConnection(rendezvous,netAddress,newConnection): print("Connected: "+str(netAddress)) newConnection = newConnection.p() self.active_conns.append(newConnection) # Remember connection self.c_reader.addConnection(newConnection) # Begin reading connection return Task.cont def tsk_reader_pol(self, taskdata): if self.c_reader.dataAvailable(): datagram=NetDatagram() # catch the incoming data in this instance # Check the return value; if we were threaded, someone else could have # snagged this data before we did if self.c_reader.getData(datagram): self.data_process(datagram) return Task.cont def data_process(self, datagram): it = PyDatagramIterator(datagram) message = it.getString() print("Processed: "+message+" from: "+str(datagram.getAddress())) def listen(self): print("Now listening on all addresses on port 9099") self.tcp_socket = self.c_manager.openTCPServerRendezvous("0.0.0.0", 9099, 1000) self.c_listener.addConnection(self.tcp_socket) taskMgr.add(self.tsk_listener_pol, "Poll connection listener", -39) taskMgr.add(self.tsk_reader_pol, "Pol the connection reader", -40) def unlisten(self): print("Stopping listen") self.c_manager.closeConnection(self.tcp_socket)
def __init__(self, host="localhost", port=5001, name="server"): super().__init__(host=host, port=port, name=name) # self.setReaderCallback( sel.ProcessReaderData ) backlog = 1000 self.tcpSocket = self.cManager.openTCPServerRendezvous(port, backlog) self.cListener = QueuedConnectionListener(self.cManager, 0) self.cListener.addConnection(self.tcpSocket) self.taskMgr.add(self.tskListenerPolling, "Poll the connection listener", -39)
def __init__(self): self.socket = None self.hostName = None self.port = None self.ourChannel = 100001 self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0)
class Server(AbsNetwork): __metaclass__ = Singleton def __init__(self): AbsNetwork.__init__(self) self.c_listener = None self.tcp_socket = None self.connection_cb = None self.listener_tsk = None self.connections = [] def start(self, reader_cb, connection_cb): AbsNetwork.start(self, reader_cb) self.connection_cb = connection_cb self.c_listener = QueuedConnectionListener(self.c_mgr, 0) self.connections = [] self.tcp_socket = self.c_mgr.open_TCP_server_rendezvous(9099, 1000) self.c_listener.add_connection(self.tcp_socket) self.listener_tsk = eng.add_tsk(self.tsk_listener, -39) eng.log_mgr.log('the server is up') def tsk_listener(self, task): if not self.c_listener.newConnectionAvailable(): return task.cont net_address = NetAddress() new_connection = PointerToConnection() args = PointerToConnection(), net_address, new_connection if not self.c_listener.get_new_connection(*args): return task.cont self.connections.append(new_connection.p()) self.c_reader.add_connection(self.connections[-1]) self.connection_cb(net_address.get_ip_string()) msg = 'received a connection from ' + net_address.getIpString() eng.log_mgr.log(msg) return task.cont def _actual_send(self, datagram, receiver): dests = [cln for cln in self.connections if cln == receiver] \ if receiver else self.connections map(lambda cln: self.c_writer.send(datagram, cln), dests) def destroy(self): AbsNetwork.destroy(self) map(self.c_reader.remove_connection, self.connections) self.c_mgr.close_connection(self.tcp_socket) taskMgr.remove(self.listener_tsk) self.c_listener = self.tcp_socket = self.connection_cb = \ self.listener_tsk = self.connections = None eng.log_mgr.log('the server has been destroyed')
def __init__(self, port, backlog=1000, compress=False): DirectObject.__init__(self) self.port = port self.compress = compress self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.passedData = [] self.connect(port, backlog) self.startPolling()
def connection_open(self): self.cManager = QueuedConnectionManager() self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager,0) self.activeConnections=[] # We'll want to keep track of these later self.cListener = QueuedConnectionListener(self.cManager, 0) port_address=9099 #No-other TCP/IP services are using this port backlog=1000 #If we ignore 1,000 connection attempts, something is wrong! self.tcpSocket = self.cManager.openTCPServerRendezvous(port_address,backlog) self.cListener.addConnection(self.tcpSocket) print "Network Connection Opened" taskMgr.add(self.tskListenerPolling,"Poll the connection listener",-39) taskMgr.add(self.tskReaderPolling,"Poll the connection reader",-40)
def __init__(self): self.activeConnections = [] # lists all connections self.players = {} # keys are the players logins, values are the players datagram connections self.parties = {} # keys are the parties names, values are dicts representing parties data self.sessions = {} # keys are the datagram connections, values are dicts storing the characters of the player and its party self.playersinlobby = [] # lists players in the party screen self.charid = 0 # used for random team generation self.chars = [] # lists of dicts representing characters data self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cReader.setTcpHeaderSize(4) self.send = Send(self.cManager) port = 3001 if len(sys.argv) > 1: port = sys.argv[1] self.tcpSocket = self.cManager.openTCPServerRendezvous(port, 10) self.cListener.addConnection(self.tcpSocket) print("Server listening on port", port) taskMgr.add(self.tskListenerPolling, "Poll the connection listener", -39) taskMgr.add(self.tskReaderPolling, "Poll the connection reader", -40)
def __init__(self): ShowBase.__init__(self) self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.player = Player() self.opponents = dict() self.logStat = -1 host = "localhost" port = 9252 self.connection = self.cManager.openTCPClientConnection( host, port, 10000) self.received = 1 self.playersText = [] if self.connection: self.cReader.addConnection(self.connection) taskMgr.add(self.updateRoutine, 'updateRoutine') taskMgr.add(self.login, 'login') #taskMgr.doMethodLater(3, self.updateRoutine, 'updateRoutine') taskMgr.doMethodLater(.1, self.heartbeat, 'heartbeat') self.accept("q", self.listPlayers) self.accept("q-up", self.delistPlayers) self.accept("escape", self.disconnect) self.accept("arrow_up", self.move)
def __init__(self, host="localhost", port=5001): taskMgr = Task.TaskManager() self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.activeConnections = [] # We'll want to keep track of these later self.readerCallbacks = [] backlog = 1000 #If we ignore 1,000 connection attempts, something is wrong! self.tcpSocket = self.cManager.openTCPServerRendezvous(port, backlog) self.cListener.addConnection(self.tcpSocket) taskMgr.add(self.tskListenerPolling, "Poll the connection listener", -39) taskMgr.add(self.tskReaderPolling, "Poll the connection reader", -40) print("started server! ({} at {})".format(port, host))
def setupTCP(self): self.tcpManager = QueuedConnectionManager() self.tcpReader = QueuedConnectionReader(self.tcpManager, 0) self.tcpWriter = ConnectionWriter(self.tcpManager, 0) self.tcpListener = QueuedConnectionListener(self.tcpManager, 0) self.tcpSocket = self.tcpManager.openTCPServerRendezvous(self.config.TCPPORT, self.config.BACKLOG) self.tcpListener.addConnection(self.tcpSocket) print ("Started Server on: ", self.config.HOSTNAME, self.config.TCPPORT)
class Server(ClientServerBase): def __init__(self, host="localhost", port=5001, name="server"): super().__init__(host=host, port=port, name=name) # self.setReaderCallback( sel.ProcessReaderData ) backlog = 1000 self.tcpSocket = self.cManager.openTCPServerRendezvous(port, backlog) self.cListener = QueuedConnectionListener(self.cManager, 0) self.cListener.addConnection(self.tcpSocket) self.taskMgr.add(self.tskListenerPolling, "Poll the connection listener", -39) def tskListenerPolling(self, taskdata): if self.cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.cListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() self.connections.append(newConnection) # Remember connection self.cReader.addConnection( newConnection) # Begin reading connection print("server: received new connection!") return Task.cont # TODO(victor): what happens when a connection drops away? def BroadcastMessage(self, datagram): # send the same message to all clients for con in self.connections: self.cWriter.send(datagram, con) # def ProcessReaderData( self, data ): # # TODO(vicdie): overwrite in derived classes # pass def Close(self): # remove all clients for con in self.connections: self.cReader.removeConnection(con) self.connections = [] self.cManager.closeConnection(self.tcpSocket)
def __init__(self, address, port, handler, backlog=10000): NetworkManager.__init__(self) self.__address = address self.__port = port self.__handler = handler self.__backlog = backlog self.__manager = QueuedConnectionManager() self.__listener = QueuedConnectionListener(self.__manager, 0) self.__reader = QueuedConnectionReader(self.__manager, 0) self.__writer = ConnectionWriter(self.__manager, 0) self.__socket = None self.__handlers = {} self.__listen_task = None self.__read_task = None self.__disconnect_task = None
def startHost (self): """ Finishes initialization and begins listening. """ # Initialize Reader and Writer: self._connReader = QueuedConnectionReader(self._connManager, 0) self._connWriter = ConnectionWriter(self._connManager, 0) # Initialize Listener: self._connListener = QueuedConnectionListener(self._connManager, 0) self._tcpSocket = self._connManager.openTCPServerRendezvous( self._portAddress, self._backlog) self._connListener.addConnection(self._tcpSocket) # Begin handling messages (start listening): taskMgr.add(self._onListenerPoll,"Poll the connection listener",-39) taskMgr.add(self._onReaderPoll,"Poll the connection reader",-40) self._isActive = True print ("[Host Started at %s]" % socket.gethostbyname( socket.gethostname())) self._gameManager.onHostInitialized()
def __init__(self): self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.rqTable = ServerRequestTable() self.rsTable = ServerResponseTable() self.connection = None
def __init__(self, protocol): """ """ net.NetCommon.__init__(self, protocol) self.listener = QueuedConnectionListener(self.manager, 0) self.connections = [] self.players = [] self.protocol.setServer(self) self.active = False self.controller = None self.packetHelper = packet.ServerPacketHelper(self)
def __init__(self): super().__init__() # Support objects self.manager = QueuedConnectionManager() self.listener = QueuedConnectionListener(self.manager, 0) self.reader = QueuedConnectionReader(self.manager, 0) self.writer = ConnectionWriter(self.manager, 0) self.handler = Handler(self) # Server model self.session_manager = SessionManager() self.notifier_manager = NotifierManager(self) self.task_manager = TaskManager(self) self.connections = [] # Socket self.tcp_socket = self.manager.open_TCP_server_rendezvous(15000, 1000) self.listener.add_connection(self.tcp_socket) self.accept_event(Event.CLIENT_DISCONNECTION_PUBLISHED, self.close_connection)
class Client(ShowBase): # notify notify = directNotify.newCategory("lp") # network cManager = QueuedConnectionManager() cListener = QueuedConnectionListener(cManager, 0) cReader = QueuedConnectionReader(cManager, 0) cWriter = ConnectionWriter(cManager, 0) def __init__(self): ShowBase.__init__(self) ShowBase.set_background_color(self, 0.08, 0.08, 0.08, 1) render.setAntialias(AntialiasAttrib.MAuto) self.disableMouse() # create father self.father = Father(self.cWriter, self.cManager, self.cReader) # create messager self.messager = Messager(self.father) # inputs self.accept('escape', self.debug) # try to connect self.connect() def debug(self): # testing_alert = Alert(-1) self.father.set_active_level(NIGHT) def connect(self): port_address = SERVER_PORT ip_address = SERVER_IP timeout = 3000 my_connection = self.cManager.openTCPClientConnection( ip_address, port_address, timeout) if my_connection: self.notify.info("Connected") self.father.set_connection(my_connection) self.cReader.addConnection(my_connection) # tasks taskMgr.add(self.messager.check_for_message, "Poll the connection reader", -39) taskMgr.doMethodLater(HEARTBEAT_PLAYER, self.messager.heartbeat, "Send heartbeat") else: Alert(-2) self.father.failed_to_connect() self.notify.warning("Could not connect!")
def SetupCommunication(self): cManager = QueuedConnectionManager() cListener = QueuedConnectionListener(cManager, 0) cReader = QueuedConnectionReader(cManager, 0) self.activeConnections = [] # We'll want to keep track of these later port_address = 9098 # No-other TCP/IP services are using this port backlog = 1000 # If we ignore 1,000 connection attempts, something is wrong! tcpSocket = cManager.openTCPServerRendezvous(port_address, backlog) cListener.addConnection(tcpSocket) def tskListenerPolling(taskdata): if cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if cListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() self.activeConnections.append( newConnection) # Remember connection cReader.addConnection( newConnection) # Begin reading connection return Task.cont def tskReaderPolling(taskdata): if cReader.dataAvailable(): datagram = NetDatagram( ) # catch the incoming data in this instance # Check the return value; if we were threaded, someone else could have # snagged this data before we did if cReader.getData(datagram): self.myProcessDataFunction(datagram) return Task.cont self.taskMgr.add(tskReaderPolling, "Poll the connection reader", -40) self.taskMgr.add(tskListenerPolling, "Poll the connection listener", -39)
def __init__(self, port=None, host=None, ip_addr="127.0.0.1", backlog=10000, timeout=5000): self.port = port # our port self.host = host # host port self.ip_addr = ip_addr self.backlog = backlog self.timeout = timeout self.socket = None self.connection = None self.active_connections = [] self.handler = None self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0)
def attemptLogin(self): # checks to make sure the user inputed a username and password: # if they didn't it will spit out an error message # if they did, it will try to connect to the login server # (under construction) if(self.usernameBox.get() == ""): if(self.passwordBox.get() == ""): self.updateStatus("ERROR: You must enter a username and password before logging in.") else: self.updateStatus("ERROR: You must specify a username") self.passwordBox['focus'] = 0 self.usernameBox['focus'] = 1 elif(self.passwordBox.get() == ""): self.updateStatus("ERROR: You must enter a password") self.usernameBox['focus'] = 0 self.passwordBox['focus'] = 1 elif(self.password2Box.get() == ""): self.updateStatus("ERROR: You must confirm the password") self.passwordBox['focus'] = 0 self.password2Box['focus'] = 1 elif(self.passwordBox.get() != self.password2Box.get()): self.updateStatus("ERROR: Wrong confirmed password, please enter password again") self.passwordBox.set("") self.password2Box.set("") self.passwordBox['focus'] = 1 self.password2Box['focus'] = 0 self.usernameBox['focus'] = 0 else: self.updateStatus("Attempting to login...") print "Attempting to connect to Server with credentials: (" + self.usernameBox.get() + ", " + self.passwordBox.get() + ")" # this is where the networking code will get put in self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) HOST = "localhost"; PORT = 1234; self.connection = self.cManager.openTCPClientConnection(HOST, PORT, 10000) self.received = 1 if self.connection: self.cReader.addConnection(self.connection) #taskMgr.add(self.updateRoutine, 'updateRoutine') taskMgr.doMethodLater(3, self.updateRoutine, 'updateRoutine')
def __init__(self): self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) try: host = "localhost" port = 9252 self.connection = self.cManager.openTCPClientConnection( host, port, 10000) self.received = 1 if self.connection: self.cReader.addConnection(self.connection) taskMgr.add(self.updateRoutine, 'updateRoutine') # taskMgr.add(self.message, 'message') except: pass
def __init__(self): ShowBase.__init__(self) self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) host = "localhost" port = 6002 self.connection = self.cManager.openTCPClientConnection( host, port, 10000) self.received = 1 if self.connection: self.cReader.addConnection(self.connection) #taskMgr.add(self.updateRoutine, 'updateRoutine') # LOGIN Request Starts self.uname = raw_input('Enter username :'******'Enter password :'******'Login') if (self.received): print "->Client request:" # Send a request to the server myPyDatagram101 = PyDatagram() prot = 101 myPyDatagram101.addUint16(prot) myPyDatagram101.addString(self.uname) myPyDatagram101.addString(self.password) self.cWriter.send(myPyDatagram101, self.connection) self.received = 0 taskMgr.add(self.receiveResponse101, 'Login')
class Server(net.NetCommon): """ """ def __init__(self, protocol): """ """ net.NetCommon.__init__(self, protocol) self.listener = QueuedConnectionListener(self.manager, 0) self.connections = [] self.players = [] self.protocol.setServer(self) self.active = False self.controller = None self.packetHelper = packet.ServerPacketHelper(self) def start(self, port): socket = self.manager.openTCPServerRendezvous(port, 100) self.listener.addConnection(socket) taskMgr.add(self.updateListener, "update_listener") def stop(self): del self.connections[:] del self.players[:] self.listener = None taskMgr.remove("update_listener") def updateListener(self, task): """ """ if self.listener.newConnectionAvailable(): connection = PointerToConnection() if self.listener.getNewConnection(connection): connection = connection.p() self.connections.append(connection) self.reader.addConnection(connection) logging.info("New connection established") self.players.append(Player(connection)) for conn in self.connections[:]: if not self.reader.isConnectionOk(conn): logging.warning("Non-ok connection detected") for player in self.players: if player.connection == conn: self.players.remove(player) nick = player.nick logging.info("Removed player with non-ok connection") messenger.send("player_disconnected", sentArgs=[nick]) self.connections.remove(conn) return task.cont def startGame(self): self.controller = controller.ServerController(self.players[0], self.players[1]) messenger.send("send_start_game", [self.players]) taskMgr.doMethodLater(1, self.controller.begin_game, "begin_game") def broadcast(self, datagram): for conn in self.connections: self.writer.send(datagram, conn) def sendToSelectedPlayers(self, datagram, players): for p in players: conn = p.connection self.writer.send(datagram, conn) def destroy(self): """ """ net.NetCommon.destroy(self) taskMgr.remove("update_listener")
class SocketTCP(ShowBase): def __init__(self, _parent=None): ShowBase.__init__(self, windowType = 'none') print ("TCP Protocol Startup...") #self.parent = _parent #self.config = self.parent.server.config # tmp config self.tcpport = 6000 self.backlog = 10 self.hostname = '127.0.0.1' self.sendPacketQueue = None def startAll(self): self.setupTCP() self.startTCPTasks() def setupTCP(self): self.tcpManager = QueuedConnectionManager() self.tcpReader = QueuedConnectionReader(self.tcpManager, 0) self.tcpWriter = ConnectionWriter(self.tcpManager, 0) self.tcpListener = QueuedConnectionListener(self.tcpManager, 0) self.tcpSocket = self.tcpManager.openTCPServerRendezvous(self.tcpport, self.backlog) self.tcpListener.addConnection(self.tcpSocket) print ("Started Server on: ", self.hostname, self.tcpport) def startTCPTasks(self): taskMgr.add(self.tcpListenerTask, "tcpListenerTask", 0) print ("TCP Listener Started") taskMgr.add(self.tcpReaderTask, "tcpReaderTask", -10) print ("TCP Reader Started") taskMgr.add(self.tcpDisconnectionHandler, "tcpDisconnectionHandler", 20) print ("TCP Disconnection Handler Started") taskMgr.add(self.tcpQueuedSendHandlerTask, "tcpQueuedSendhandlerTask", -11) print ("TCP Queued Send Handler Started") # TCP Listener Task def tcpListenerTask(self, task): """ Accept new incoming connection from clients, related to TCP """ # Handle new connection if self.tcpListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.tcpListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() # Tell the reader about the new TCP connection self.tcpReader.addConnection(newConnection) #self.core.createPlayerObject(generateUUID(),newConnection, netAddress) print ("Server: " + str(generateUUID), str(netAddress.getIpString())) else: print ("Server: Connection Failed from -", str(netAddress.getIpString())) return Task.cont def tcpReaderTask(self, task): """ Handle any data from clients by sending it to the Handlers. """ while 1: (datagram, data, opcode) = self.tcpNonBlockingRead(self.tcpReader) if opcode is MSG_NONE: # Do nothing or use it as some 'keep_alive' thing. break else: # Handle it #self.core.packetManager.handlePacket(opcode, data, datagram.getAddress()) print("Set Packet Handler to handle packets!") return Task.cont # TCP NonBlockingRead?? def tcpNonBlockingRead(self, qcr): """ Return a datagram collection and type if data is available on the queued connection udpReader """ if self.tcpReader.dataAvailable(): datagram = NetDatagram() if self.tcpReader.getData(datagram): data = DatagramIterator(datagram) opcode = data.getUint8() else: data = None opcode = MSG_NONE else: datagram = None data = None opcode = MSG_NONE # Return the datagram to keep a handle on the data return (datagram, data, opcode) # TCP Disconnection Handler def tcpDisconnectionHandler(self, task): # Check for resets if self.tcpManager.resetConnectionAvailable(): resetConnection = PointerToConnection() self.tcpManager.getResetConnection(resetConnection) print(str(resetConnection.p())) #for client in self.core.server.clients: # if self.core.server.clients[client].connection == resetConnection.p(): # del self.core.server.clients[client] # self.tcpReader.removeConnection(resetConnection.p()) # print ("Removed Connection:", resetConnection.p()) # print ('Current Clients:', self.core.server.clients) # break return Task.cont def sendPacket(self, _pkt, _connection): self.tcpWriter.send(_pkt, _connection) def sendBroadcast(self, _pkt, _skipif=None): for client in self.serverManager.clients: if _skipif == client: pass else: conn = self.serverManager.clients[client].connection self.tcpWriter.send(_pkt, conn) def addPacketToSendQueue(self, _data): # _data should contain packet and connection pass def addPacketToBroadcastQueue(self, _pkt, _connectionList): # _data should contain the pkt data and _connectionList should be the valid connections for that broadcast # Could have a grouping system that put clients together and broadcasts go per group pass def tcpQueuedSendHandlerTask(self, task): if not self.sendPacketQueue.isEmpty(): self.addPacketToSendQueue(self.sendPacketQueue.removeFromQue()) return Task.cont
class TCP(): def __init__(self, _core): print("TCP Protocol Startup...") self.core = _core self.config = self.core.server.config def start(self): self.setupTCP() self.startTCPTasks() def setupTCP(self): self.tcpManager = QueuedConnectionManager() self.tcpReader = QueuedConnectionReader(self.tcpManager, 0) self.tcpWriter = ConnectionWriter(self.tcpManager, 0) self.tcpListener = QueuedConnectionListener(self.tcpManager, 0) self.tcpSocket = self.tcpManager.openTCPServerRendezvous( self.config.TCPPORT, self.config.BACKLOG) self.tcpListener.addConnection(self.tcpSocket) print("Started Server on: ", self.config.HOSTNAME, self.config.TCPPORT) def startTCPTasks(self): taskMgr.add(self.tcpListenerTask, "tcpListenerTask", 0) print("TCP Listener Started") taskMgr.add(self.tcpReaderTask, "tcpReaderTask", -10) print("TCP Reader Started") taskMgr.add(self.tcpDisconnectionHandler, "tcpDisconnectionHandler", 20) print("TCP Disconnection Handler Started") # TCP Listener Task def tcpListenerTask(self, task): """ Accept new incoming connection from clients, related to TCP """ # Handle new connection if self.tcpListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.tcpListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() # Tell the reader about the new TCP connection self.tcpReader.addConnection(newConnection) # Handle the connection depending on persistent or not if self.core.server.isPersistent: self.core.handleConnection(generateUUID(), newConnection, netAddress) else: self.core.createPlayerObject(generateUUID(), newConnection, netAddress) print("Server: New Connection from -", str(netAddress.getIpString())) else: print("Server: Connection Failed from -", str(netAddress.getIpString())) return Task.cont def tcpReaderTask(self, task): """ Handle any data from clients by sending it to the Handlers. """ while 1: (datagram, data, opcode) = self.tcpNonBlockingRead(self.tcpReader) if opcode is MSG_NONE: # Do nothing or use it as some 'keep_alive' thing. break else: # Handle it self.core.packetManager.handlePacket(opcode, data, datagram.getAddress()) return Task.cont # TCP NonBlockingRead?? def tcpNonBlockingRead(self, qcr): """ Return a datagram collection and type if data is available on the queued connection udpReader """ if self.tcpReader.dataAvailable(): datagram = NetDatagram() if self.tcpReader.getData(datagram): data = DatagramIterator(datagram) opcode = data.getUint8() else: data = None opcode = MSG_NONE else: datagram = None data = None opcode = MSG_NONE # Return the datagram to keep a handle on the data return (datagram, data, opcode) # TCP Disconnection Handler def tcpDisconnectionHandler(self, task): # Check for resets if self.tcpManager.resetConnectionAvailable(): resetConnection = PointerToConnection() self.tcpManager.getResetConnection(resetConnection) for client in self.core.server.clients: if self.core.server.clients[ client].connection == resetConnection.p(): del self.core.server.clients[client] self.tcpReader.removeConnection(resetConnection.p()) print("Removed Connection:", resetConnection.p()) print('Current Clients:', self.core.server.clients) break return Task.cont def sendPacket(self, _pkt, _connection): self.tcpWriter.send(_pkt, _connection) def sendBroadcast(self, _pkt, _skipif=None): for client in self.serverManager.clients: if _skipif == client: pass else: conn = self.serverManager.clients[client].connection self.tcpWriter.send(_pkt, conn)
class TCP(): def __init__(self, _core): print ("TCP Protocol Startup...") self.core = _core self.config = self.core.server.config def start(self): self.setupTCP() self.startTCPTasks() def setupTCP(self): self.tcpManager = QueuedConnectionManager() self.tcpReader = QueuedConnectionReader(self.tcpManager, 0) self.tcpWriter = ConnectionWriter(self.tcpManager, 0) self.tcpListener = QueuedConnectionListener(self.tcpManager, 0) self.tcpSocket = self.tcpManager.openTCPServerRendezvous(self.config.TCPPORT, self.config.BACKLOG) self.tcpListener.addConnection(self.tcpSocket) print ("Started Server on: ", self.config.HOSTNAME, self.config.TCPPORT) def startTCPTasks(self): taskMgr.add(self.tcpListenerTask, "tcpListenerTask", 0) print ("TCP Listener Started") taskMgr.add(self.tcpReaderTask, "tcpReaderTask", -10) print ("TCP Reader Started") taskMgr.add(self.tcpDisconnectionHandler, "tcpDisconnectionHandler", 20) print ("TCP Disconnection Handler Started") # TCP Listener Task def tcpListenerTask(self, task): """ Accept new incoming connection from clients, related to TCP """ # Handle new connection if self.tcpListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.tcpListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() # Tell the reader about the new TCP connection self.tcpReader.addConnection(newConnection) # Handle the connection depending on persistent or not if self.core.server.isPersistent: self.core.handleConnection(generateUUID(), newConnection, netAddress) else: self.core.createPlayerObject(generateUUID(),newConnection, netAddress) print ("Server: New Connection from -", str(netAddress.getIpString())) else: print ("Server: Connection Failed from -", str(netAddress.getIpString())) return Task.cont def tcpReaderTask(self, task): """ Handle any data from clients by sending it to the Handlers. """ while 1: (datagram, data, opcode) = self.tcpNonBlockingRead(self.tcpReader) if opcode is MSG_NONE: # Do nothing or use it as some 'keep_alive' thing. break else: # Handle it self.core.packetManager.handlePacket(opcode, data, datagram.getAddress()) return Task.cont # TCP NonBlockingRead?? def tcpNonBlockingRead(self, qcr): """ Return a datagram collection and type if data is available on the queued connection udpReader """ if self.tcpReader.dataAvailable(): datagram = NetDatagram() if self.tcpReader.getData(datagram): data = DatagramIterator(datagram) opcode = data.getUint8() else: data = None opcode = MSG_NONE else: datagram = None data = None opcode = MSG_NONE # Return the datagram to keep a handle on the data return (datagram, data, opcode) # TCP Disconnection Handler def tcpDisconnectionHandler(self, task): # Check for resets if self.tcpManager.resetConnectionAvailable(): resetConnection = PointerToConnection() self.tcpManager.getResetConnection(resetConnection) for client in self.core.server.clients: if self.core.server.clients[client].connection == resetConnection.p(): del self.core.server.clients[client] self.tcpReader.removeConnection(resetConnection.p()) print ("Removed Connection:", resetConnection.p()) print ('Current Clients:', self.core.server.clients) break return Task.cont def sendPacket(self, _pkt, _connection): self.tcpWriter.send(_pkt, _connection) def sendBroadcast(self, _pkt, _skipif=None): for client in self.serverManager.clients: if _skipif == client: pass else: conn = self.serverManager.clients[client].connection self.tcpWriter.send(_pkt, conn)
from panda3d.core import QueuedConnectionManager from panda3d.core import QueuedConnectionListener from panda3d.core import QueuedConnectionReader from panda3d.core import ConnectionWriter from panda3d.core import NetDatagram from panda3d.core import PointerToConnection from panda3d.core import NetAddress from direct.task.TaskManagerGlobal import taskMgr cManager = QueuedConnectionManager() cListener = QueuedConnectionListener(cManager, 0) cReader = QueuedConnectionReader(cManager, 0) cWriter = ConnectionWriter(cManager, 0) activeConnections = [] # We'll want to keep track of these later port_address = 9099 # No-other TCP/IP services are using this port backlog = 1000 # If we ignore 1,000 connection attempts, something is wrong! tcpSocket = cManager.openTCPServerRendezvous(port_address, backlog) cListener.addConnection(tcpSocket) def tskListenerPolling(taskdata): if cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection()
class ConnectionManager: notify = DirectNotifyGlobal.directNotify.newCategory("ConnectionManager") def __init__(self): self.socket = None self.hostName = None self.port = None self.ourChannel = 100001 self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) def start(self): self.hostName = base.configManager.getString('host-name', '127.0.0.1') self.port = base.configManager.getInt('port-number', 6667) self.socket = self.cManager.openTCPServerRendezvous( self.hostName, self.port, 1000) if self.socket: self.cListener.addConnection(self.socket) self._serverStarted(self.hostName, self.port) taskMgr.add(self._socketListener, 'Connection Listener') taskMgr.add(self._socketReader, 'Connection Reader') else: self.notify.warning( "Unable to start server on %s:%d - is the port in use?" % (self.hostName, self.port)) base.logManager.writeServerEvent( 'ServerBase', 'Unable to start server on %s:%d - is the port in use?' % (self.hostName, self.port)) sys.exit() def _serverStarted(self, host, port): self.notify.warning("Server started on %s:%d" % (host, port)) base.logManager.writeServerEvent( 'ServerBase', 'Server started on %s:%d' % (host, port)) def _socketListener(self, task): if self.cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.cListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() base.activeConnections[newConnection] = NetworkedClient() self.cReader.addConnection(newConnection) self.notify.warning("New Unauthed Client Connected: %s" % (netAddress)) return Task.cont def _socketReader(self, task): if self.cReader.dataAvailable(): datagram = NetDatagram() if self.cReader.getData(datagram): base.messageManager.handleMessage(datagram) return Task.cont
class Server: def __init__(self): self.port = 5555 self.addr = "127.0.0.1" self.backlog = 7 self.active_connections = dict() self.start = False self.connect() def connect(self) -> None: # Handle connections and terminations self.manager = QueuedConnectionManager() # Wait for clients connection requests self.listener = QueuedConnectionListener(self.manager, 0) # Buffers incoming data from active connection self.reader = QueuedConnectionReader(self.manager, 0) # Transmit PyDatagrams to active connection self.writer = ConnectionWriter(self.manager, 0) # Open TCP Rendezvous to accept client connections with a limit self.socket = self.manager.openTCPServerRendezvous( self.port, self.backlog) self.listener.addConnection(self.socket) print("Server listening on port %s...." % str(self.port)) # Listen for mew incoming connections taskMgr.add(self.handle_incoming_connections, "Poll the connection listener", -39) # Listen for new datagrams taskMgr.add(self.handle_connection_data, "Poll the connection reader", -40) # Listen for dropped connections taskMgr.add(self.handle_dropped_connections, "Poll the dropped connection listener", -41) # See if game can be started taskMgr.add(self.start_game, "Start Game", -42) def start_game(self, task_data: Task) -> Task: if len(self.active_connections) == self.backlog: self.start = True return Task.cont def handle_incoming_connections(self, task_data: Task) -> Task: if self.listener.newConnectionAvailable(): rendezvous = PointerToConnection() net_addr = NetAddress() new_connection = PointerToConnection() if self.listener.getNewConnection(rendezvous, net_addr, new_connection): new_connection = new_connection.p() # Keep track of our active connections self.active_connections[str( new_connection.this)] = new_connection # Start reading the new connection self.reader.addConnection(new_connection) print("%s just connected" % str(new_connection)) return Task.cont def handle_connection_data(self, task_data: Task) -> Task: if self.reader.dataAvailable(): # Catch the incoming data datagram = NetDatagram() if self.reader.getData(datagram): name = self.handle_client_message(datagram) broadcast = f"Everyone, welcome {name} to the game!" self.broadcast_message(broadcast) return Task.cont def handle_dropped_connections(self, task_data: Task) -> Task: if self.manager.resetConnectionAvailable(): connection_pointer = PointerToConnection() self.manager.getResetConnection(connection_pointer) lost_connection = connection_pointer.p() print("% s disconnected from server" % str(lost_connection)) del self.active_connections[str(lost_connection.this)] self.manager.closeConnection(lost_connection) return Task.cont def handle_client_message(self, message: str) -> str: iterator = PyDatagramIterator(message) return iterator.getString() def get_connections_count(self) -> int: return len(self.active_connections) def send_personal_message(self, message: str, client: PointerToConnection) -> None: datagram = self.create_new_datagram(message) self.writer.send(datagram, client) def broadcast_message(self, message: str) -> None: datagram = self.create_new_datagram(message) for client in self.active_connections: self.writer.send(datagram, self.active_connections[client]) def create_new_datagram(self, message: str) -> PyDatagram: new_datagram = PyDatagram() new_datagram.addString(message) return new_datagram def terminate_all_clients(self) -> None: for client in self.active_connections: self.reader.removeConnection(client) self.active_connections = list() def terminate_specific_client(self, client: PointerToConnection) -> None: self.reader.removeConnection(client) del self.active_connections[str(client)]
class NetworkListener(NetworkManager): notify = directNotify.newCategory('NetworkListener') def __init__(self, address, port, handler, backlog=10000): NetworkManager.__init__(self) self.__address = address self.__port = port self.__handler = handler self.__backlog = backlog self.__manager = QueuedConnectionManager() self.__listener = QueuedConnectionListener(self.__manager, 0) self.__reader = QueuedConnectionReader(self.__manager, 0) self.__writer = ConnectionWriter(self.__manager, 0) self.__socket = None self.__handlers = {} self.__listen_task = None self.__read_task = None self.__disconnect_task = None def setup(self): if not self.__socket: self.__socket = self.__manager.open_TCP_server_rendezvous( self.__address, self.__port, self.__backlog) if not self.__socket: raise NetworkError( 'Failed to bind TCP socket on address: <%s:%d>!' % (self.__address, self.__port)) self.__listener.add_connection(self.__socket) self.__listen_task = task_mgr.add( self.__listen_incoming, self.get_unique_name('listen-incoming'), taskChain=task_chain) self.__read_task = task_mgr.add(self.__read_incoming, self.get_unique_name('read-incoming'), taskChain=task_chain) self.__disconnect_task = task_mgr.add( self.__listen_disconnect, self.get_unique_name('listen-disconnect'), taskChain=task_chain) def __listen_incoming(self, task): """ Polls for incoming connections """ if self.__listener.new_connection_available(): rendezvous = PointerToConnection() address = NetAddress() connection = PointerToConnection() if self.__listener.get_new_connection(rendezvous, address, connection): self.__handle_connection(rendezvous, address, connection.p()) return task.cont def __read_incoming(self, task): """ Polls for incoming data """ if self.__reader.data_available(): datagram = NetworkDatagram() if self.__reader.get_data(datagram): self.__handle_data(datagram, datagram.get_connection()) return task.cont def __listen_disconnect(self, task): """ Watches all connected socket objects and determines if the stream has ended... """ for handler in self.__handlers.values(): if not self.__reader.is_connection_ok(handler.connection): handler.handle_disconnected() return task.cont def __has_handler(self, connection): """ Returns True if the handler is queued else False """ return connection in self.__handlers def __add_handler(self, handler): """ Adds a handler to the handlers dictionary """ if self.__has_handler(handler.connection): return handler.setup() self.__handlers[handler.connection] = handler self.__reader.add_connection(handler.connection) def __remove_handler(self, handler): """ Removes a handler from the handlers dictionary """ if not self.__has_handler(handler.connection): return handler.shutdown() self.__reader.remove_connection(handler.connection) del self.__handlers[handler.connection] def __handle_connection(self, rendezvous, address, connection): """ Handles an incoming connection from the connection listener """ handler = self.__handler(self, rendezvous, address, connection) self.__add_handler(handler) def __handle_data(self, datagram, connection): """ Handles new data incoming from the connection reader """ if not self.__has_handler(connection): return self.__handlers[connection].queue(datagram) def get_handler_from_channel(self, channel): """ Returns a handler instance if one is associated with that channel """ for connection, handler in self.__handlers.items(): if handler.channel == channel: return handler return None def handle_send_datagram(self, datagram, connection): """ Sends a datagram to a specific connection """ if not self.__has_handler(connection): return self.__writer.send(datagram, connection) def handle_disconnect(self, handler): """ Disconnects the handlers client socket instance """ self.__manager.close_connection(handler.connection) def handle_disconnected(self, handler): """ Handles disconnection of a client socket instance """ self.__remove_handler(handler) def shutdown(self): if self.__listen_task: task_mgr.remove(self.__listen_task) if self.__read_task: task_mgr.remove(self.__read_task) if self.__disconnect_task: task_mgr.remove(self.__disconnect_task) self.__listen_task = None self.__read_task = None self.__disconnect_task = None self.__listener.remove_connection(self.__socket)
class NetworkManager: def __init__(self): print "Network Manager Started" def connection_open(self): self.cManager = QueuedConnectionManager() self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager,0) self.activeConnections=[] # We'll want to keep track of these later self.cListener = QueuedConnectionListener(self.cManager, 0) port_address=9099 #No-other TCP/IP services are using this port backlog=1000 #If we ignore 1,000 connection attempts, something is wrong! self.tcpSocket = self.cManager.openTCPServerRendezvous(port_address,backlog) self.cListener.addConnection(self.tcpSocket) print "Network Connection Opened" taskMgr.add(self.tskListenerPolling,"Poll the connection listener",-39) taskMgr.add(self.tskReaderPolling,"Poll the connection reader",-40) def connection_close(self): for aClient in self.activeConnections: self.cReader.removeConnection(aClient) self.activeConnections=[] # close down our listener self.cManager.closeConnection(self.tcpSocket) print "Network Connection Closed" def tskListenerPolling(self, taskdata): if self.cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.cListener.getNewConnection(rendezvous,netAddress,newConnection): newConnection = newConnection.p() self.activeConnections.append(newConnection) # Remember connection self.cReader.addConnection(newConnection) # Begin reading connection return Task.cont def tskReaderPolling(self, taskdata): if self.cReader.dataAvailable(): datagram=NetDatagram() # catch the incoming data in this instance # Check the return value; if we were threaded, someone else could have # snagged this data before we did if self.cReader.getData(datagram): if base.client == True: self.client_processing(datagram) else: self.server_processing(datagram) return Task.cont def server_messager(self,msg,args=[]): if msg == "map_set": order = PyDatagram() order.addUint16(MAP_SET) order.addInt32(args[0]) self.send_package(order) elif msg == "client_update": order = PyDatagram() order.addUint16(CLIENT_INIT_UPDATE) order.addString(args[0]) order.addString(args[1]) order.addInt32(args[2]) order.addInt32(args[3]) self.send_package(order) elif msg == "chat_send": r = args[0][0] g = args[0][1] b = args[0][2] order = PyDatagram() order.addUint16(SERVER_CHAT) order.addInt32(r) order.addInt32(g) order.addInt32(b) order.addString(args[1]) self.send_package(order) base.menu_manager.menus["mp-game"].chat_add((r,g,b,1),args[1]) elif msg == "ready_button": order = PyDatagram() order.addUint16(SERVER_READY) order.addInt32(args[0]) order.addInt32(args[1]) self.send_package(order) base.menu_manager.menus["mp-game"].obj_list[args[0]]["indicatorValue"]=args[1] base.menu_manager.menus["mp-game"].start_game_check() elif msg == "server_loaded": order = PyDatagram() order.addUint16(SERVER_LOADED) self.send_package(order) elif msg == "all_loaded": order = PyDatagram() order.addUint16(ALL_LOADED) self.send_package(order) elif msg == "game_start": order = PyDatagram() order.addUint16(GAME_START) self.send_package(order) elif msg == "army_kill": order = PyDatagram() order.addUint16(ARMY_KILL) order.addInt32(args[0]) self.send_package(order) elif msg == "build_start": order = PyDatagram() order.addUint16(BUILD_START) order.addInt32(args[0]) order.addInt8(args[1]) order.addString(args[2]) self.send_package(order) elif msg == "tower_capture": order = PyDatagram() order.addUint16(TOWER_CAPTURE) order.addInt32(args[0]) order.addInt8(args[1]) self.send_package(order) elif msg == "build_complete": order = PyDatagram() order.addUint16(BUILD_COMPLETE) order.addInt32(args[0]) order.addInt8(args[1]) order.addString(args[2]) self.send_package(order) elif msg == "build_cancel": order = PyDatagram() order.addUint16(BUILD_CANCEL) order.addInt32(args[0]) self.send_package(order) elif msg == "battle_start": order = PyDatagram() order.addUint16(BATTLE_START) order.addInt32(args[0]) order.addFloat32(args[1]) order.addFloat32(args[2]) order.addInt32(args[3]) order.addFloat32(args[4]) order.addFloat32(args[5]) order.addInt32(args[6]) self.send_package(order) elif msg == "battle_clash": order = PyDatagram() order.addUint16(BATTLE_CLASH) order.addInt32(args[0]) order.addInt32(args[1]) order.addInt32(args[2]) order.addString(args[3]) order.addInt8(args[4]) self.send_package(order) elif msg == "battle_turn": order = PyDatagram() order.addUint16(BATTLE_TURN) order.addInt32(args[0]) order.addInt32(args[1]) self.send_package(order) elif msg == "battle_end": order = PyDatagram() order.addUint16(BATTLE_END) order.addInt32(args[0]) self.send_package(order) elif msg == "battle_armyadd": order = PyDatagram() order.addUint16(BATTLE_ARMYADD) order.addInt32(args[0]) order.addInt32(args[1]) order.addFloat32(args[2]) order.addFloat32(args[3]) self.send_package(order) def client_messager(self,msg,args=[]): if msg == "chat_send": order = PyDatagram() order.addUint16(CLIENT_CHAT) order.addInt32(args[0][0]) order.addInt32(args[0][1]) order.addInt32(args[0][2]) order.addString(args[1]) self.send_package(order) elif msg == "ready_button": order = PyDatagram() order.addUint16(CLIENT_READY) order.addInt32(args[0]) order.addInt32(args[1]) self.send_package(order) elif msg == "client_loaded": order = PyDatagram() order.addUint16(CLIENT_LOADED) self.send_package(order) elif msg == "game_init_request": order = PyDatagram() order.addUint16(CLIENT_INIT_REQUEST) order.addString(args[0]) order.addString(args[1]) self.send_package(order) elif msg == "build_start_request": order = PyDatagram() order.addUint16(BUILD_START_REQUEST) order.addInt32(args[0]) order.addInt32(args[1]) order.addString(args[2]) self.send_package(order) elif msg == "build_cancel_request": order = PyDatagram() order.addUint16(BUILD_CANCEL_REQUEST) order.addInt32(args[0]) self.send_package(order) def client_processing(self,datagram): data_iter = PyDatagramIterator(datagram) msgID = data_iter.getUint16() if msgID == PRINT_MESSAGE: messageToPrint = data_iter.getString() print messageToPrint if msgID == ARMY_MOVE: army_id = data_iter.getInt16() ax = data_iter.getFloat64() ay = data_iter.getFloat64() tx = data_iter.getFloat64() ty = data_iter.getFloat64() base.armies[army_id].node_path.setX(ax) base.armies[army_id].node_path.setY(ay) base.armies[army_id].move_to_point(tx,ty) if msgID == CLIENT_INIT_UPDATE: p1_name = data_iter.getString() p1_kingdom = data_iter.getString() p1_ready = data_iter.getInt32() game_map = data_iter.getInt32() base.menu_manager.menus["mp-game"].client_update(p1_name,p1_kingdom,p1_ready,game_map) if msgID == SERVER_CHAT: r = data_iter.getInt32() g = data_iter.getInt32() b = data_iter.getInt32() text = data_iter.getString() base.menu_manager.menus["mp-game"].chat_add((r,g,b),text) if msgID == SERVER_READY: but_id = data_iter.getInt32() state = data_iter.getInt32() base.menu_manager.menus["mp-game"].obj_list[but_id]["indicatorValue"]=state base.menu_manager.menus["mp-game"].start_game_check() if msgID == SERVER_LOADED: base.menu_manager.menus["mp-load"].load() if msgID == ALL_LOADED: base.menu_manager.menus["mp-load"].load_complete() if msgID == GAME_START: base.menu_manager.menu_goto("mp-load") if msgID == MAP_SET: map = data_iter.getInt32() base.menu_manager.menus["mp-game"].map_selected = map mapname = base.menu_manager.menus["mp-game"].maplist[map]["fullname"] mapimage = base.menu_manager.menus["mp-game"].maplist[map]["preview"] base.menu_manager.menus["mp-game"].obj_list[11]["text"]=mapname base.menu_manager.menus["mp-game"].obj_list[10].setImage(mapimage) if msgID == BATTLE_TURN: bat = data_iter.getInt32() turn = data_iter.getInt32() base.battles[bat].turn_change(turn) if msgID == BATTLE_START: a1 = data_iter.getInt32() a1_x = data_iter.getFloat32() a1_y = data_iter.getFloat32() a2 = data_iter.getInt32() a2_x = data_iter.getFloat32() a2_y = data_iter.getFloat32() army_start = data_iter.getInt32() base.armies[a1].stop() base.armies[a2].stop() base.armies[a1].node_path.setPos(a1_x,a1_y,0) base.armies[a2].node_path.setPos(a2_x,a2_y,0) base.battles.append(TimObjects.Battle([base.armies[a1],base.armies[a2]],army_start)) if msgID == BATTLE_CLASH: battle = data_iter.getInt32() a1 = data_iter.getInt32() a2 = data_iter.getInt32() result = data_iter.getString() buff = data_iter.getInt8() base.battles[battle].clash(base.armies[a1],base.armies[a2],result,buff) if msgID == BATTLE_ARMYADD: bat = data_iter.getInt32() army = data_iter.getInt32() a_x = data_iter.getFloat32() a_y = data_iter.getFloat32() base.battles[bat].add_army(base.armies[army]) base.armies[army].node_path.setPos(a_x,a_y,0) if msgID == BATTLE_END: bat = data_iter.getInt32() base.battles[bat].end() if msgID == BUILD_START: t_id = data_iter.getInt32() player = data_iter.getInt8() type = data_iter.getString() base.towers[t_id].build_start() if msgID == TOWER_CAPTURE: t_id = data_iter.getInt32() player = data_iter.getInt8() base.towers[t_id].change_owner(player) if msgID == BUILD_CANCEL: t_id = data_iter.getInt32() base.towers[t_id].build_cancel() if msgID == BUILD_COMPLETE: t_id = data_iter.getInt32() player = data_iter.getInt8() type = data_iter.getString() base.towers[t_id].create_counter() def server_processing(self,datagram): data_iter = PyDatagramIterator(datagram) msgID = data_iter.getUint16() if msgID == PRINT_MESSAGE: messageToPrint = data_iter.getString() print messageToPrint if msgID == ARMY_MOVE_REQUEST: army_id = data_iter.getInt16() ax = data_iter.getFloat64() ay = data_iter.getFloat64() tx = data_iter.getFloat64() ty = data_iter.getFloat64() base.armies[army_id].set_target(False,tx,ty) if msgID == CLIENT_CHAT: r = data_iter.getInt32() g = data_iter.getInt32() b = data_iter.getInt32() text = data_iter.getString() self.server_messager("chat_send",[(r,g,b),text]) #base.main_menu.chat_add((r,g,b,1),text) if msgID == CLIENT_READY: but_id = data_iter.getInt32() state = data_iter.getInt32() self.server_messager("ready_button",[but_id,state]) #base.main_menu.chat_add((r,g,b,1),text) if msgID == CLIENT_LOADED: self.server_messager("all_loaded",[]) base.menu_manager.menus["mp-load"].load_complete() if msgID == CLIENT_INIT_REQUEST: pn = data_iter.getString() pk = data_iter.getString() base.menu_manager.menus["mp-game"].obj_list[6]["text"] = pn base.menu_manager.menus["mp-game"].obj_list[7]["text"] = pk self.server_messager("client_update",[base.menu_manager.menus["mp-game"].obj_list[4]["text"], base.menu_manager.menus["mp-game"].obj_list[5]["text"], base.menu_manager.menus["mp-game"].obj_list[8]["indicatorValue"], base.menu_manager.menus["mp-game"].map_selected]) if msgID == BUILD_START_REQUEST: t_id = data_iter.getInt32() player = data_iter.getInt32() type = data_iter.getString() base.towers[t_id].build_start() if msgID == BUILD_CANCEL_REQUEST: t_id = data_iter.getInt32() player = data_iter.getInt32() type = data_iter.getString() base.towers[t_id].build_cancel() def msgAllClients(self): myPyDatagram=self.myNewPyDatagram() # build a datagram to send for aClient in self.activeConnections: self.cWriter.send(myPyDatagram,aClient) def send_package(self,package): # print "packaged" for aClient in self.activeConnections: print "Package",package,"sent" self.cWriter.send(package,aClient) def army_move(self,army_id,tx,ty): order = PyDatagram() if base.client == True: order.addUint16(ARMY_MOVE_REQUEST) else: order.addUint16(ARMY_MOVE) ax = base.armies[army_id].node_path.getX() ay = base.armies[army_id].node_path.getY() order.addInt16(army_id) order.addFloat64(ax) order.addFloat64(ay) order.addFloat64(tx) order.addFloat64(ty) if base.client == True: self.cWriter.send(order,base.server_connection) else: self.send_package(order) base.armies[army_id].move_to_point(tx,ty) def tower_train(self,tower_id,build_object): order = PyDatagram() if base.client == True: order.addUint16(REQUEST_TOWER_TRAIN) else: order.addUint16(TOWER_TRAIN) order.addInt16(army_id) order.addFloat64(tx) order.addFloat64(ty) if base.client == True: self.cWriter.send(order,base.server_connection) else: self.send_package(order) base.towers[tower_id].train_counter() # def request_army_move(self,army_id,tx,ty): # order = PyDatagram() # order.addUint16(REQUEST_MOVE_COUNTER) # order.addInt16(army_id) # order.addFloat64(tx) # order.addFloat64(ty) # self.cWriter.send(order,base.server_connection) def myNewPyDatagram(self): # Send a test message myPyDatagram = PyDatagram() myPyDatagram.addUint16(PRINT_MESSAGE) myPyDatagram.addString("You got ze message!") return myPyDatagram def client_connect(self,ip): port_address=9099 # same for client and server # a valid server URL. You can also use a DNS name # if the server has one, such as "localhost" or "panda3d.org" ip_address=ip # how long until we give up trying to reach the server? timeout_in_miliseconds=3000 # 3 seconds base.server_connection=self.cManager.openTCPClientConnection(ip_address,port_address,timeout_in_miliseconds) if base.server_connection: self.cReader.addConnection(base.server_connection) # receive messages from server self.activeConnections.append(base.server_connection) print "Connected to server",ip return True print "Connection failed" return False
class Server: def __init__(self): self.activeConnections = [] # lists all connections self.players = {} # keys are the players logins, values are the players datagram connections self.parties = {} # keys are the parties names, values are dicts representing parties data self.sessions = {} # keys are the datagram connections, values are dicts storing the characters of the player and its party self.playersinlobby = [] # lists players in the party screen self.charid = 0 # used for random team generation self.chars = [] # lists of dicts representing characters data self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cReader.setTcpHeaderSize(4) self.send = Send(self.cManager) port = 3001 if len(sys.argv) > 1: port = sys.argv[1] self.tcpSocket = self.cManager.openTCPServerRendezvous(port, 10) self.cListener.addConnection(self.tcpSocket) print("Server listening on port", port) taskMgr.add(self.tskListenerPolling, "Poll the connection listener", -39) taskMgr.add(self.tskReaderPolling, "Poll the connection reader", -40) def processData(self, datagram): iterator = PyDatagramIterator(datagram) source = datagram.getConnection() callback = iterator.getString() getattr(globals()[callback], 'execute')(self, iterator, source) def updateAllPartyLists(self): parties = deepcopy(self.parties) for party in list(parties.values()): del party['map']['tiles'] for player in self.playersinlobby: self.send.UPDATE_PARTY_LIST(parties, player) def tskListenerPolling(self, taskdata): if self.cListener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.cListener.getNewConnection(rendezvous, netAddress, newConnection): newConnection = newConnection.p() self.activeConnections.append(newConnection) self.cReader.addConnection(newConnection) print('A new client is connected', newConnection) return Task.cont def tskReaderPolling(self, taskdata): if self.cReader.dataAvailable(): datagram=NetDatagram() if self.cReader.getData(datagram): self.processData(datagram) return Task.cont