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
