def receiveResponse106(self,task): while self.cReader.dataAvailable(): datagram6 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram6): myIterator = PyDatagramIterator(datagram6) print myIterator.getUint16() msg = myIterator.getString() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() print myIterator.getUint32() print myIterator.getUint32() print myIterator.getUint32() print myIterator.getUint32() raw_input("Press Enter to continue...") self.received = 1 # Attack #raw_input("Press Enter to continue...") taskMgr.add(self.sendRequest108, 'health') return task.again
def setReward(self, reward): dg = PyDatagram(reward) dgi = PyDatagramIterator(dg) def _unpackList(method, numItems=4): list = [] for i in xrange(numItems): size = dgi.getUint8() if not size: list.append([]) continue x = [] for i in xrange(size): x.append(method()) list.append(x) return list self.trophiesList = _unpackList(dgi.getUint8) self.rankingsList = _unpackList(dgi.getInt8, 1)[0] self.holeBestList = _unpackList(dgi.getUint8) self.courseBestList = _unpackList(dgi.getUint8) self.cupList = _unpackList(dgi.getUint8) self.tieBreakWinner = dgi.getUint32() self.aimTimesList = [dgi.getUint32() / 100.0 for _ in xrange(4)] if self.state not in ['Cleanup']: self.demand('WaitReward')
def server_task(self, task): if self.listener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.listener.getNewConnection(rendezvous, netAddress, newConnection): print 'GOT CONNECTION FROM', netAddress newConnection = newConnection.p() self.connections.append(newConnection) self.reader.addConnection(newConnection) self.last_pid += 1 self.players[netAddress.getIpString()] = Player(pid=self.last_pid, draw=False) while self.manager.resetConnectionAvailable(): connPointer = PointerToConnection() self.manager.getResetConnection(connPointer) connection = connPointer.p() print 'LOST CONNECTION FROM', connection # Remove the connection we just found to be "reset" or "disconnected" self.reader.removeConnection(connection) # Loop through the activeConnections till we find the connection we just deleted # and remove it from our activeConnections list for idx in range(0, len(self.connections)): if self.connections[idx] == connection: del self.connections[c] break while self.reader.dataAvailable(): datagram = NetDatagram() if self.reader.getData(datagram): conn = datagram.getConnection() dataIter = PyDatagramIterator(datagram) addr = conn.getAddress() player = self.players[addr.getIpString()] player.handle_move(dataIter.getString(), dataIter.getBool()) return task.cont
def process(self, data): it = PyDatagramIterator(data) msgid = it.getUint8() conn = data.getConnection() sendingPlayer = None for p in self.server.players: if p.connection == conn: sendingPlayer = p break else: logging.error("No sendingPlayer found") if msgid == ServerMsgId.keepAlive: return None elif msgid == ServerMsgId.registration: return self.handleRegistration(it, sendingPlayer) elif msgid == ServerMsgId.chatMsg: return self.handleChatMsg(it, sendingPlayer) elif msgid == ServerMsgId.tryPlayCard: return self.handleTryPlayCard(it, sendingPlayer) elif msgid == ServerMsgId.tryPutInBattleground: return self.handleTryPutInBattleground(it, sendingPlayer)
def process(self, data): it = PyDatagramIterator(data) vel = it.getFloat32() z = it.getFloat32() diff = z - self.smiley.getZ() self.smiley.setPythonTag("velocity", vel + diff * 0.03) return None
def check(self): while self.cReader.dataAvailable(): print "data here" datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): data = PyDatagramIterator(datagram) responseCode = data.getUint16() print responseCode if responseCode == 1: self.getInt(data) elif responseCode == 2: self.getString(data) elif responseCode == 3: self.getShort(data) elif responseCode == 4: self.getFloat(data) elif responseCode == 201: self.getLogin(data) elif responseCode == 203: self.getRegistion(data) elif responseCode == 204: self.getCharacterCreation(data) elif responseCode == 205: self.getChat(data) elif responseCode == 206: self.getMove(data) else: print "nothing found"
def makeFromNetString(self, string): dg = PyDatagram(string) dgi = PyDatagramIterator(dg) self.type = dgi.getFixedString(1) if self.type == 'c': self.name = sgi.getFixedString(2) else: notify.error('unknown avatar type: ', self.type)
def makeNetString(self): dataList = self.experience datagram = PyDatagram() for track in range(0, len(Tracks)): datagram.addUint16(dataList[track]) dgi = PyDatagramIterator(datagram) return dgi.getRemainingBytes()
def makeFromNetString(self, netString): dataList = [] dg = PyDatagram(netString) dgi = PyDatagramIterator(dg) for track in range(0, len(Tracks)): dataList.append(dgi.getUint16()) return dataList
def makeNetString(self): dataList = self.inventory datagram = PyDatagram() for track in range(0, len(Tracks)): for level in range(0, len(Levels[track])): datagram.addUint8(dataList[track][level]) dgi = PyDatagramIterator(datagram) return dgi.getRemainingBytes()
def process(self, data): it = PyDatagramIterator(data) msgid = it.getUint8() if msgid == 0: return self.handleHello(it) elif msgid == 1: return self.handleQuestion(it) elif msgid == 2: return self.handleBye(it)
def handle_datagram(self, datagram): connection = datagram.getConnection() if not connection: self.dump_invalid_connection(connection) di = PyDatagramIterator(datagram) if di.getUint8() == 1: self.handle_incoming(di, connection, datagram) elif di.getUint8() == BAD_CHANNEL_ID: self.handle_bad_channel(di)
def handleDatagram(self, datagram): connection = datagram.getConnection() dgi = PyDatagramIterator(datagram) message_type = dgi.getUint16() print message_type if message_type == CLIENT_HEARTBEAT: self.handleClientHeartbeat(dgi, connection) elif message_type == CLIENT_DISCONNECT: self.handleClientDisconnect(dgi, connection)
def handle_datagram_reciever(self, datagram): di = PyDatagramIterator(datagram) reciever_channel = di.getUint64() sender_channel = di.getUint64() msg_type = di.getUint16() if msg_type == STATESERVER_OBJECT_GENERATE_WITH_REQUIRED: location = (di.getUint32(), di.getUint32()) self.current_reciever = reciever_channel if location == (0, 0): print ("Tried to generate an object for an unknown location!") return self.do_interest_manager.handleGenerateWithRequired(self.current_reciever, location, di.getUint32()) if msg_type == STATESERVER_OBJECT_GENERATE_WITH_REQUIRED_OTHER: doId = di.getUint32() location = (di.getUint32(), di.getUint32()) self.current_reciever = reciever_channel if location == (0, 0): print ("Tried to generate an object for an unknown location!") return self.do_interest_manager.handleGenerateWithRequiredAndId(self.current_reciever, doId, location, di.getUint32()) else: print ("Stateserver: Recieved a message that's unknown to the protocol, from %s" % str(sender_channel)) # debug error return
def handle_datagram_reciever(self, datagram): connection = datagram.getConnection() if not connection: print ("Got an unexpected connection: %s" % str(connection)) return di = PyDatagramIterator(datagram) reciever_channel = di.getUint64() sender_channel = di.getUint64() msg_type = di.getUint16() print msg_type
def process(self, data): print "Got some data" it = PyDatagramIterator(data) msgid = it.getUint8() if msgid == 0: print "Got 0 key mssg" return self.handleHello(it) elif msgid == 1: return self.handleQuestion(it) elif msgid == 2: return self.handleBye(it)
def __makeList(self, store): list = [] if self.__blob: dg = PyDatagram(self.__blob) di = PyDatagramIterator(dg) versionNumber = di.getUint8() while di.getRemainingSize() > 0: item = CatalogItem.decodeCatalogItem(di, versionNumber, store) list.append(item) return list
def getItem(blob, store = 0): dg = PyDatagram(blob) di = PyDatagramIterator(dg) try: versionNumber = di.getUint8() return decodeCatalogItem(di, versionNumber, store) except Exception, e: CatalogItem.notify.warning('Invalid catalog item: %s, %s' % (sys.exc_info()[0], e)) dg.dumpHex(Notify.out()) import CatalogInvalidItem return CatalogInvalidItem.CatalogInvalidItem()
def makeFromNetString(self, string): dg = PyDatagram(string) dgi = PyDatagramIterator(dg) self.type = dgi.getFixedString(1) if self.type == 's': self.name = dgi.getFixedString(3) self.dept = dgi.getFixedString(1) self.body = getSuitBodyType(self.name) elif self.type == 'b': self.dept = dgi.getFixedString(1) else: notify.error('unknown avatar type: ', self.type)
def update(self, task): while self.reader.dataAvailable(): datagram = NetDatagram() if self.reader.getData(datagram): dataIter = PyDatagramIterator(datagram) pid = dataIter.getInt8() x = dataIter.getFloat32() y = dataIter.getFloat32() if pid not in self.players: print 'NEW PLAYER', pid self.players[pid] = Player(pid=pid, draw=True) self.players[pid].move_to(x, y) return task.cont
def createGardenFromData(self, gardenData): dg = PyDatagram(gardenData) gardenData = PyDatagramIterator(dg) plotCount = gardenData.getUint8() for _ in xrange(plotCount): occupier = gardenData.getUint8() if occupier not in occupier2Class: continue plot = occupier2Class[occupier](self.air, self, self.house.housePos) plot.construct(gardenData) plot.generateWithRequired(self.house.zoneId) self.plots.append(plot)
def nonBlockingRead(self, qcr): if self.cReader.dataAvailable(): datagram = NetDatagram() if self.cReader.getData(datagram): data = PyDatagramIterator(datagram) msgID = data.getUint16() else: data = None msgID = MSG_NONE else: datagram = None data = None msgID = MSG_NONE return (datagram, data, msgID)
def load_file(self): self.is_loading = True file = open(self.filepath, 'rb') data = file.read() file.close() dg = PyDatagram(data) data = PyDatagramIterator(dg) for _ in xrange(data.get_uint8()): self.load_button(data) self.is_loading = False
def TCPPacketListenTask(self, task): if self.tcpReader.dataAvailable(): datagram = NetDatagram() if self.tcpReader.getData(datagram): data = PyDatagramIterator(datagram) ip = datagram.getAddress().getIpString() port = datagram.getAddress().getPort() peerAddr = NetAddress() peerAddr.setHost(ip, port) packetType = data.getUint8() if(packetType == Packet.PC_TCP_PACKET): self.tcpPacketController.OnPacketReceived(data, peerAddr) return task.cont
def handle_datagram(self, datagram): self.connection = datagram.getConnection() if not self.connection: pass # TODO! di = PyDatagramIterator(datagram) msg_type = di.getUint16() print msg_type # debug if msg_type == CLIENT_HEARTBEAT: self.handle_client_heartbeat(self.connection, di) elif msg_type == CLIENT_DISCONNECT: self.remove_connection_instance(self.connection) else: print ("Recieved an unexpected datagram: %s from: %s" % (msg_type, str(self.connection)))
def receiveResponse102(self,task): print "<-Server response:" while self.cReader.dataAvailable(): datagram2 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram2): myIterator = PyDatagramIterator(datagram2) print myIterator.getUint16() msg = myIterator.getUint16() print msg, " received" if msg is not None: raw_input("Press Enter to continue...") self.received = 1 # Register raw_input("Press Enter to continue...") taskMgr.add(self.communicate301, 'Heartbeat')
def makeFromNetStringForceSize(self, netString, numTracks, numLevels): dataList = [] dg = PyDatagram(netString) dgi = PyDatagramIterator(dg) for track in range(0, numTracks): subList = [] for level in range(0, numLevels): if dgi.getRemainingSize() > 0: value = dgi.getUint8() else: value = 0 subList.append(value) dataList.append(subList) return dataList
def receiveResponse101(self,task): while self.cReader.dataAvailable(): datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): self.myIterator = PyDatagramIterator(datagram) print "<-Server response:" print self.myIterator.getUint16() self.msg = self.myIterator.getUint32() self.l = self.myIterator.getUint32() if self.msg is not None: if self.l is not 0: for x in range(0,self.l): print self.myIterator.getString() print self.myIterator.getUint32() print self.myIterator.getUint32() print self.msg, " received" #raw_input("Press Enter to continue...") self.received = 0 taskMgr.remove('Login') #1-Character creatopm #taskMgr.add(self.sendRequest104, 'CharacterCreation') #2-heartbeat of playgame after login MyApp.sendRequest113(self) return task.again
def updateRoutine(self, task): """A once-per-frame task used to read packets from the socket.""" while self.cReader.dataAvailable(): # Create a datagram to store all necessary data. datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): # Prepare the datagram to be iterated. data = PyDatagramIterator(datagram) # Retrieve a "short" that contains the response code. responseCode = data.getUint16() # Pass into another method to execute the response. if responseCode != Constants.MSG_NONE: self.handleResponse(responseCode, data) return task.cont
def makeFromNetString(self, netString): dataList = [] dg = PyDatagram(netString) dgi = PyDatagramIterator(dg) for track in xrange(0, len(Tracks)): subList = [] for level in xrange(0, len(Levels[track])): if dgi.getRemainingSize() > 0: value = dgi.getUint8() else: value = 0 subList.append(value) dataList.append(subList) return dataList
def loadDNAFileBase(self, dnaStorage, file): self.dnaStorage = dnaStorage dnaFile = open(file, 'rb') dnaData = dnaFile.read() dg = PyDatagram(dnaData) dgi = PyDatagramIterator(dg) dnaFile.close() header = dgi.extractBytes(5) if header != 'PDNA\n': raise DNAError.DNAError('Invalid header: %s' % (header)) compressed = dgi.getBool() dgi.skipBytes(1) if compressed: data = dgi.getRemainingBytes() data = zlib.decompress(data) dg = PyDatagram(data) dgi = PyDatagramIterator(dg) self.handleStorageData(dgi) self.handleCompData(dgi)
def __displaySingleMsg(self, task): msg = self.__msgs.pop(0) dg = PyDatagram() dg.addString(msg) dgi = PyDatagramIterator(dg) self.cr.handleSystemMessage(dgi) if self.__msgs: task.delayTime = 3 return task.again else: return task.done
def check(self): while self.cReader.dataAvailable(): print "data here" datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): data = PyDatagramIterator(datagram) responseCode = data.getUint16() print responseCode if responseCode == 201: self.getPlayer(data) elif responseCode == 202: self.register(data) elif responseCode == 203: self.getOpponent(data) elif responseCode == 214: self.movePlayer(data) elif responseCode == 215: self.stopPlayer(data) elif responseCode == 219: self.dropPlayer(data) else: print "nothing found"
def fromNetString(self, netString): self.tracks.clear() dg = PyDatagram(netString) dgi = PyDatagramIterator(dg) avDoId = dgi.getUint32() favGagId = dgi.getUint8() self.avatar = base.cr.doId2do.get(avDoId, None) self.avatarName = None if not self.avatar else self.avatar.getName() self.favoriteGag = base.cr.attackMgr.getAttackName(favGagId) while dgi.getRemainingSize() > 0: track = GagGlobals.TrackNameById.get(dgi.getUint8()) exp = dgi.getInt16() maxExp = dgi.getInt16() increment = dgi.getInt16() self.tracks[track] = Track(track, exp, maxExp, increment) return avDoId
def check_for_message(self, taskdata): """ Called repeatedly to check if there's any new messages """ if self.cReader.dataAvailable(): dg = NetDatagram() if self.cReader.getData(dg): iterator = PyDatagramIterator(dg) connection = dg.getConnection() try: msg_id = iterator.getUint8() except AssertionError: self.notify.warning("[check_for_message] No message ID") return Task.cont # check if real msg_id if msg_id in self.mapping: self.mapping[msg_id](self, iterator) else: self.notify.warning( "[check_for_message] Invalid msg_id: {}".format( msg_id)) return Task.cont
def tcpNonBlockingRead(self, qcr): """ Return a datagram collection and type if data is available on the queued connection tcpReader @param qcr: self.tcpReader """ if self.tcpReader.dataAvailable(): datagram = NetDatagram() if self.tcpReader.getData(datagram): data = PyDatagramIterator(datagram) opcode = data.getUint16() 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)
def server_task(self, task): if self.listener.newConnectionAvailable(): rendezvous = PointerToConnection() netAddress = NetAddress() newConnection = PointerToConnection() if self.listener.getNewConnection(rendezvous, netAddress, newConnection): print 'GOT CONNECTION FROM', netAddress newConnection = newConnection.p() self.connections.append(newConnection) self.reader.addConnection(newConnection) self.last_pid += 1 self.players[netAddress.getIpString()] = Player( pid=self.last_pid, draw=False) while self.manager.resetConnectionAvailable(): connPointer = PointerToConnection() self.manager.getResetConnection(connPointer) connection = connPointer.p() print 'LOST CONNECTION FROM', connection # Remove the connection we just found to be "reset" or "disconnected" self.reader.removeConnection(connection) # Loop through the activeConnections till we find the connection we just deleted # and remove it from our activeConnections list for idx in range(0, len(self.connections)): if self.connections[idx] == connection: del self.connections[c] break while self.reader.dataAvailable(): datagram = NetDatagram() if self.reader.getData(datagram): conn = datagram.getConnection() dataIter = PyDatagramIterator(datagram) addr = conn.getAddress() player = self.players[addr.getIpString()] player.handle_move(dataIter.getString(), dataIter.getBool()) return task.cont
def check_for_message(self, taskdata): """ Called repeatedly to check if any new messages from server This gets the information from said datagram and calls whatever function necessary @param self @param taskdata """ if self.cReader.dataAvailable(): dg = NetDatagram() if self.cReader.getData(dg): iterator = PyDatagramIterator(dg) try: msg_id = iterator.getUint8() except AssertionError: self.notify.warning("[check_for_message] Invalid msg_id!") return Task.cont if msg_id in self.mapping: self.mapping[msg_id](self, iterator) else: self.notify.warning( f"[check_for_message] Unknown msg_id: {msg_id}") return Task.cont
def constructTree(self, plotIndex, gagTrack, gagLevel): dg = PyDatagram() dg.addUint8(plotIndex) dg.addUint8(GardenGlobals.getTreeTypeIndex(gagTrack, gagLevel)) # Type Index dg.addInt8(0) # Water Level dg.addInt8(0) # Growth Level dg.addUint32(self.getTimestamp()) dg.addUint8(0) # Wilted State (False) gardenData = PyDatagramIterator(dg) plot = occupier2Class[GardenGlobals.TreePlot](self.air, self, self.house.housePos) plot.construct(gardenData) self.plots[plotIndex] = plot self.updateGardenData()
def __init__(self, connectMethod, config, hasOwnerView=False, threadedNet=None, dcStream=None): if threadedNet is None: threadedNet = config.GetBool('threaded-net', False) self.dcStream = dcStream CConnectionRepository.__init__(self, hasOwnerView, threadedNet) self.setWantMessageBundling(config.GetBool('want-message-bundling', 1)) DoInterestManager.__init__(self) DoCollectionManagerOR.__init__(self) self.setPythonRepository(self) self.uniqueId = hash(self) self.accept(self._getLostConnectionEvent(), self.lostConnection) self.config = config if self.config.GetBool('verbose-repository'): self.setVerbose(1) userConnectMethod = self.config.GetString('connect-method', 'default') if userConnectMethod == 'http': connectMethod = self.CM_HTTP elif userConnectMethod == 'net': connectMethod = self.CM_NET elif userConnectMethod == 'native': connectMethod = self.CM_NATIVE self.connectMethod = connectMethod if self.connectMethod == self.CM_HTTP: self.notify.info("Using connect method 'http'") elif self.connectMethod == self.CM_NET: self.notify.info("Using connect method 'net'") elif self.connectMethod == self.CM_NATIVE: self.notify.info("Using connect method 'native'") self.connectHttp = None self.http = None self.private__di = PyDatagramIterator() self.recorder = None self.readerPollTaskObj = None self.dcSuffix = '' self._serverAddress = '' if self.config.GetBool('gc-save-all', 1): gc.set_debug(gc.DEBUG_SAVEALL) if self.config.GetBool('want-garbage-collect-task', 1): taskMgr.add(self._garbageCollect, self.GarbageCollectTaskName, 200) taskMgr.doMethodLater( self.config.GetFloat('garbage-threshold-adjust-delay', 300.0), self._adjustGcThreshold, self.GarbageThresholdTaskName) self._gcDefaultThreshold = gc.get_threshold()
def __init__(self, config, hasOwnerView=False): BaseDOManager.__init__(self, hasOwnerView) self.netSys = NetworkSystem() self.netCallbacks = NetworkCallbacks() self.netCallbacks.setCallback(self.__handleNetCallback) self.connected = False self.connectionHandle = None self.connectSuccessCallback = None self.connectFailureCallback = None self.msgType = 0 self.config = config # Accept this hook so that we can respond to lost-connection # events in the main thread, instead of within the network # thread (if there is one). self.accept(self._getLostConnectionEvent(), self.lostConnection) # This DatagramIterator is constructed once, and then re-used # each time we read a datagram. self.private__di = PyDatagramIterator() self._serverAddress = '' self.readerPollTaskObj = None if self.config.GetBool('gc-save-all', 1): # set gc to preserve every object involved in a cycle, even ones that # would normally be freed automatically during garbage collect # allows us to find and fix these cycles, reducing or eliminating the # need to run garbage collects # garbage collection CPU usage is O(n), n = number of Python objects gc.set_debug(gc.DEBUG_SAVEALL) if self.config.GetBool('want-garbage-collect-task', 1): # manual garbage-collect task taskMgr.add(self._garbageCollect, self.GarbageCollectTaskName, 200) # periodically increase gc threshold if there is no garbage taskMgr.doMethodLater( self.config.GetFloat('garbage-threshold-adjust-delay', 5 * 60.), self._adjustGcThreshold, self.GarbageThresholdTaskName) self._gcDefaultThreshold = gc.get_threshold()
def handle_data(self, datagram: PyDatagram) -> None: """ Handling new data. First, message is obtained, then correct message handler is called """ iterator = PyDatagramIterator(datagram) # parse message try: message = self.message_parser(iterator, MessageType.response) response = self.handle_message(message) self.handle_response(response) except KeyError as e: log.exception(e) log.error("Unsupported message.") return
def constructFlower(self, plotIndex, species, variety): dg = PyDatagram() dg.addUint8(plotIndex) dg.addUint8(species) dg.addUint16(variety) dg.addInt8(0) # Water Level dg.addInt8(0) # Growth Level dg.addUint32(self.getTimestamp()) dg.addUint8(0) # Wilted State (False) gardenData = PyDatagramIterator(dg) plot = occupier2Class[GardenGlobals.FlowerPlot](self.air, self, self.house.housePos) plot.construct(gardenData) self.plots[plotIndex] = plot self.updateGardenData()
def receiveResponse112(self, task): while self.cReader.dataAvailable(): datagram12 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram12): myIterator = PyDatagramIterator(datagram12) print myIterator.getUint16() msg = myIterator.getUint32() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() raw_input("Press Enter to continue...") self.received = 1
def constructStatuary(self, plotIndex, typeIndex): dg = PyDatagram() dg.addUint8(plotIndex) dg.addUint8(typeIndex) gardenData = PyDatagramIterator(dg) occupier = GardenGlobals.StatuaryPlot if typeIndex in GardenGlobals.ChangingStatuaryTypeIndices: occupier = GardenGlobals.ChangingStatuaryPlot elif typeIndex in GardenGlobals.AnimatedStatuaryTypeIndices: occupier = GardenGlobals.AnimatedStatuaryPlot plot = occupier2Class[occupier](self.air, self, self.house.housePos) plot.construct(gardenData) self.plots[plotIndex] = plot self.updateGardenData()
def handle_data(self, datagram, connection, session): """ Handling new data. First, message is obtained, then correct message handler is called """ iterator = PyDatagramIterator(datagram) # parse message try: message = self.message_parser(iterator, MessageType.request) except KeyError as e: log.exception(e) log.error("unsuppoerted message") return # produce response response = self.handle_message(session, message) # send response self.handle_response(connection, response)
def receiveResponse107(self, task): while self.cReader.dataAvailable(): datagram7 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram7): myIterator = PyDatagramIterator(datagram7) print myIterator.getUint16() msg = myIterator.getString() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() raw_input("Press Enter to continue...") self.received = 1 # Change Health taskMgr.add(self.sendRequest112, 'CP Capture') return task.again
def update(self, task): while self.reader.dataAvailable(): datagram = NetDatagram() if self.reader.getData(datagram): update = PyDatagramIterator(datagram) num_objects = update.getInt8() for i in range(num_objects): name = update.getString() x = update.getFloat32() y = update.getFloat32() z = update.getFloat32() h = update.getFloat32() p = update.getFloat32() r = update.getFloat32() if name.startswith( 'Walker') and name not in self.world.objects: self.world.create_walker(name) obj = self.world.objects.get(name) if obj: obj.move((x, y, z)) obj.rotate(h, p, r) return task.cont
def setDNAString(self, dnaStr): data = PyDatagram(dnaStr) iter = PyDatagramIterator(data) self.setShapeStyle(int(iter.getUint8())) bgData = [0] * len(self.bgData) layoutData = [0] * len(self.layoutData) for x in range(len(bgData)): bgData[x] = int(iter.getUint8()) self.setBackground(*bgData) for x in range(len(layoutData)): layoutData[x] = int(iter.getUint8()) self.setLayout(*layoutData) self.emblems = {} eCount = 0 while iter.getRemainingSize() >= len(self.DefaultEmblemData): edata = self.DefaultEmblemData[:] for x in range(0, len(edata)): edata[x] = int(iter.getUint8()) self.setEmblem(eCount, *edata) eCount += 1
def receiveResponse301(self): while self.cReader.dataAvailable(): datagram301 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram301): myIterator = PyDatagramIterator(datagram301) p = myIterator.getUint16() if p == 213: un = myIterator.getString() cname = myIterator.getString() ctype = myIterator.getUint32() cteam = myIterator.getUint32() if un == MyApp.uname: abc = 'abc' else: print cname + ' just joined a game......!! hurray' #print msg, " received" self.received = 1
def myProcessDataFunction(datagram): global status, P1NAME, P2NAME, lastResetRequest global MY_POSITION, kicker, texKicker, texKicker2, mode if (role == ROLE_SERVER): sender = activeConnections.index(datagram.getConnection()) data = PyDatagramIterator(datagram) #try: if True: #just to keep the indent, in case we need "try" again. pktType = data.getUint16() if role == ROLE_SERVER: # packets received only by server if pktType == PACKET_MOVE: setOpponentMove(data, sender + 1) elif pktType == PACKET_MSG: timer = data.getUint16() msg = data.getString() sendMessage(msg, timer) #broadcast to all elif pktType == PACKET_HELLO: magic = data.getString() proto = data.getUint16() soft = data.getString() if magic != MAGIC_WORD: print "Connecting party did not identify as netkickern client." sys.exit(1) if proto != PROTOCOL_VERSION: print "Connecting party used incompatible protocol version " + str( proto) + "." print "We are using " + str(PROTOCOL_VERSION) + "." sys.exit(1) if soft != SOFTWARE_VERSION: print "WARNING: Client is using software " + soft + "." print "Ok, client " + str(sender + 1) + " connected." status = STATUS_INIT qpref = PyDatagram() #query for client preferences qpref.addUint16(PACKET_QPREF) qpref.addString(SOFTWARE_VERSION) cWriter.send(qpref, activeConnections[sender]) elif pktType == PACKET_PREF: if status != STATUS_INIT: return prefs = {} teamname = data.getString() prefs['team'] = teamname place = -1 if (mode == MODE_4P): #assign the last free position, and P1 only if the teamname matches or everything else is given away if not POSITION[3]: place = 3 if not POSITION[2]: place = 2 if (teamname == TEAMNAME) or (place == -1): if not POSITION[1]: place = 1 print "placed player ", sender + 1, " at position ", place POSITION[place] = sender + 1 prefs['pos'] = place playerPrefs[sender] = prefs if (mode == MODE_2P) or (0 in playerPrefs and 1 in playerPrefs and 2 in playerPrefs): P1NAME = TEAMNAME P2NAME = playerPrefs[0]['team'] rename = PyDatagram() rename.addUint16(PACKET_NAME) rename.addString(P1NAME) rename.addString(P2NAME) toAll(rename, activeConnections) if (mode == MODE_4P ): #inform players of the position they play in for i in range(0, 3): placing = PyDatagram() placing.addUint16(PACKET_PLACE) placing.addUint16(playerPrefs[i]['pos']) cWriter.send(placing, activeConnections[i]) resetNames() welcome = PyDatagram() welcome.addUint16(PACKET_START) toAll(welcome, activeConnections) startGame() elif pktType == PACKET_PONG: stime = data.getFloat64() now = time.time() deltatime = now - stime # TODO: use this to delay mouse movements by avg(deltatime)/2 print "player " + str(sender) + " network delay: " + str( deltatime * 500) + "ms " #rtt/2 elif pktType == PACKET_RESET: lastResetRequest = time.time() playerPrefs[sender]['lastReset'] = lastResetRequest if not isResetConfirmed(): resetRequest = PyDatagram() #forward to all clients resetRequest.addUint16(PACKET_RESET) #resetRequest.addUint16(sender) # TODO: tell everyone which player sent the request toAll(resetRequest, activeConnections) setMessage( "Player " + str(sender + 1) + " wishes to reset the ball.\nPress Space to confirm.", 3) else: # packets received only by clients if pktType == PACKET_SET: setGameStatus(data) elif pktType == PACKET_SCORE: setScore(data) elif pktType == PACKET_QPREF: soft = data.getString() if soft != SOFTWARE_VERSION: print "WARNING: Server is using software " + soft + "." status = STATUS_INIT pref = PyDatagram() pref.addUint16(PACKET_PREF) pref.addString(TEAMNAME) cWriter.send(pref, serverConnection) elif pktType == PACKET_START: print "connection to game host confirmed." startGame() elif pktType == PACKET_MSG: timer = data.getUint16() msg = data.getString() setMessage(msg, timer) elif pktType == PACKET_NAME: P1NAME = data.getString() P2NAME = data.getString() resetNames() elif pktType == PACKET_PLACE: #4P only MY_POSITION = data.getUint16() mode = MODE_4P resetGameColours(kicker, texKicker, texKicker2) elif pktType == PACKET_PING: stime = data.getFloat64() pong = PyDatagram() pong.addUint16(PACKET_PONG) pong.addFloat64(stime) cWriter.send(pong, serverConnection) elif pktType == PACKET_RESET: setMessage( "Another wishes to reset the ball.\nPress Space to confirm.", 3) #except Exception, e: # print e # sys.exit(1) #wow, this is what I call exception handling.. return
class Server(QueuedConnectionManager): """Handles new connections and the incomming of packages""" def __init__(self, p, b): self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.port = p self.backlog = b self.socket = self.cManager.openTCPServerRendezvous( self.port, self.backlog) self.cListener.addConnection(self.socket) self.player_list = [] self.iterator = None self.num_count = self.active_players = self.Δt_update = self.Δt = 0 def reader_polling_task(self, arg): if self.cReader.dataAvailable(): datagram = NetDatagram() if self.cReader.getData(datagram): self.process_data(datagram.getConnection(), datagram) return Task.cont def listener_polling_task(self, arg): if self.cListener.newConnectionAvailable(): rendezvous = PointerToConnection() net_address = NetAddress() new_connection = PointerToConnection() if self.cListener.getNewConnection(rendezvous, net_address, new_connection): self.active_players += 1 new_connection = new_connection.p() self.player_list.append(player(self.num_count)) find_player(self.player_list, "player_id", self.num_count).conn_id = new_connection logging.debug(self.active_players) self.initialize_player() self.num_count += 1 self.cReader.addConnection( new_connection) # Begin reading connection logging.info('connection received') return Task.cont def initialize_player(self): conn = self.player_list[-1].conn_id datagram = PyDatagram() datagram.addString("init") newest = self.player_list[-1].player_id datagram.addUint8(newest) logging.debug( f"{self.active_players} players and {newest} is the newest player") datagram.addUint8(self.active_players) if len(self.player_list) > 1: for k in self.player_list: datagram.addString(k.username) datagram.addFloat64(k.pos_and_or['x']) datagram.addFloat64(k.pos_and_or['y']) datagram.addFloat64(k.pos_and_or['z']) self.cWriter.send(datagram, conn) def update_positions(self, data): # send self.Δt = globalClock.getDt() self.Δt_update += self.Δt if self.Δt_update > 0.05: if self.active_players > 1: datagram = PyDatagram() datagram.addString("update") datagram.addInt8(self.active_players) for p in self.player_list: datagram.addString(p.username) datagram.addFloat64(p.pos_and_or['x']) datagram.addFloat64(p.pos_and_or['y']) datagram.addFloat64(p.pos_and_or['z']) datagram.addFloat64(p.pos_and_or['h']) datagram.addFloat64(p.pos_and_or['p']) datagram.addFloat64(p.pos_and_or['r']) for p in self.player_list: self.cWriter.send(datagram, p.conn_id) self.Δt_update = 0 return Task.cont def update_chat(self, msg): datagram = PyDatagram() datagram.addString("chat") datagram.addString(msg) logging.info(f"{msg}") # TODO make this useful for p in self.player_list: self.cWriter.send(datagram, p.conn_id) def process_data(self, connection, datagram): self.iterator = PyDatagramIterator(datagram) msg_type = self.iterator.getString() if msg_type == "position": self.process_position(connection) elif msg_type == "chat": self.update_chat(self.iterator.getString()) elif msg_type == "introduce": username = self.iterator.getString() logging.info(f"User {username} introduced himself") cls = find_player(self.player_list, "conn_id", connection) cls.username = username elif msg_type == "quit": self.process_quit() def process_position(self, connection): it = self.iterator pos_and_or = find_player(self.player_list, "conn_id", connection).pos_and_or pos_and_or['x'] = it.getFloat64() pos_and_or['y'] = it.getFloat64() pos_and_or['z'] = it.getFloat64() pos_and_or['h'] = it.getFloat64() pos_and_or['p'] = it.getFloat64() pos_and_or['r'] = it.getFloat64() def process_quit(self): logging.debug("Player has quit") self.active_players -= 1 player_num = self.iterator.getInt8() player_cls = find_player(self.player_list, "player_id", player_num) player_id = self.player_list.index(player_cls) player_name = player_cls.username del self.player_list[player_id] datagram = PyDatagram() datagram.addString("remove") datagram.addString(player_name) for p in self.player_list: self.cWriter.send(datagram, p.conn_id) logging.info(f"Player {player_name} has left the game")
def handle_client_message(self, message: str) -> str: iterator = PyDatagramIterator(message) return iterator.getString()
def __gotOwnerAv(self, db, retcode): assert (self.notify.debug("__gotOwnerAv(%s, %s): %s" % (db.values.keys(), retcode, self.doId))) if retcode != 0: self.notify.warning("Avatar %s for house %s does not exist!" % (self.ownerId, self.doId)) return # The avatar still exists, so check its properties. onOrder = None mailboxContents = None awardMailboxContents = None dg = db.values.get('setDeliverySchedule') if dg: di = PyDatagramIterator(dg) blob = di.getString() onOrder = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Customization | CatalogItem.DeliveryDate) dg = db.values.get('setMailboxContents') if dg: di = PyDatagramIterator(dg) blob = di.getString() mailboxContents = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Customization) dg = db.values.get('setMaxHp') if dg: di = PyDatagramIterator(dg) hp = di.getUint16() dg = db.values.get('setAwardMailboxContents') if dg: di = PyDatagramIterator(dg) blob = di.getString() awardMailboxContents = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Customization) #self.b_setCannonEnabled(1) self.__checkMailbox(onOrder, mailboxContents, 0, awardMailboxContents)
def processData(self, netDatagram): myIterator = PyDatagramIterator(netDatagram) return self.decode(myIterator.getString())
class PlayerReg(DirectObject): def __init__(self): self.PlayerList = [] self.active = 0 self.timeSinceLastUpdate = 0 def updatePlayers(self, serverClass, data, type): if (type == "positions"): self.elapsed = globalClock.getDt() self.timeSinceLastUpdate += self.elapsed if (self.timeSinceLastUpdate > 0.1): if (self.active): self.datagram = PyDatagram() self.datagram.addString("update") self.datagram.addFloat64(self.active) for k in range(self.active): self.datagram.addFloat64( self.PlayerList[k].currentPos['x']) self.datagram.addFloat64( self.PlayerList[k].currentPos['y']) self.datagram.addFloat64( self.PlayerList[k].currentPos['z']) self.datagram.addFloat64( self.PlayerList[k].currentPos['h']) self.datagram.addFloat64( self.PlayerList[k].currentPos['p']) self.datagram.addFloat64( self.PlayerList[k].currentPos['r']) for k in self.PlayerList: self.conn = k.connectionID serverClass.cWriter.send(self.datagram, self.conn) self.timeSinceLastUpdate = 0 return Task.cont if (type == "chat"): self.iterator = data self.datagram = PyDatagram() self.datagram.addString("chat") self.text = self.iterator.getString() self.datagram.addString(self.text) for k in self.PlayerList: serverClass.cWriter.send(self.datagram, k.connectionID) def updateData(self, connection, datagram, serverClass): self.iterator = PyDatagramIterator(datagram) self.type = self.iterator.getString() if (self.type == "positions"): for k in self.PlayerList: if (k.connectionID == connection): k.currentPos['x'] = self.iterator.getFloat64() k.currentPos['y'] = self.iterator.getFloat64() k.currentPos['z'] = self.iterator.getFloat64() k.currentPos['h'] = self.iterator.getFloat64() k.currentPos['p'] = self.iterator.getFloat64() k.currentPos['r'] = self.iterator.getFloat64() if (self.type == "chat"): self.updatePlayers(serverClass, self.iterator, "chat") def sendInitialInfo(self, i, server): self.con = self.PlayerList[i].connectionID self.datagram = PyDatagram() self.datagram.addString("init") self.datagram.addUint8(self.active) self.datagram.addFloat64(i) for k in self.PlayerList: self.datagram.addString(k.username) self.datagram.addFloat64(k.currentPos['x']) self.datagram.addFloat64(k.currentPos['y']) self.datagram.addFloat64(k.currentPos['z']) server.cWriter.send(self.datagram, self.con)
def readHeader(self, datagram): dgi = PyDatagramIterator(datagram) number = dgi.getUint32() dtype = dgi.getUint8() self.notify.debug("Packet %d type %d received" % (number, dtype)) return (dgi, dtype)
def processPacket(self, packet, backend, sender=None): iterator = PyDatagramIterator(packet) lastId = "None" lastController = "None" try: rebroadcast = True while iterator.getRemainingSize() > 0: type = net.Uint8.getFrom(iterator) if type == constants.PACKET_CONTROLLER: rebroadcast = True id = net.Uint8.getFrom(iterator) entity = backend.entityGroup.getEntity(id) if entity is not None: lastId = str(id) lastController = entity.controller entity.controller.clientUpdate(backend.aiWorld, backend.entityGroup, iterator) else: engine.log.warning( "Received controller packet with no matching entity. ID: " + str(id) + " Last entity updated: " + lastId + " - controller: " + str(lastController)) # Only send a request once every two seconds if sender is not None and ( (id not in list(self.requestedEntitySpawns.keys())) or (engine.clock.time - self.requestedEntitySpawns[id] > 2.0)): p = net.Packet() p.add( net.Uint8(constants.PACKET_REQUESTSPAWNPACKET)) p.add(net.Uint8(id)) net.context.send(p, sender) self.requestedEntitySpawns[id] = engine.clock.time engine.log.info( "Sending request for missing entity spawn packet. Entity ID: " + str(id)) return rebroadcast elif type == constants.PACKET_SPAWN: controllerType = net.Uint8.getFrom(iterator) entity = controllers.types[controllerType].readSpawnPacket( backend.aiWorld, backend.entityGroup, iterator) if entity.getId() in list( self.requestedEntitySpawns.keys()): del self.requestedEntitySpawns[entity.getId()] if entity is not None and backend.entityGroup.getEntity( entity.getId()) is None: backend.entityGroup.addEntity(entity) elif entity is not None: engine.log.warning( "Spawned entity " + str(entity.getId()) + " already exists. Cancelling spawn.") entity.delete(backend.entityGroup, killed=False, localDelete=False) rebroadcast = True elif type == constants.PACKET_DELETE: id = net.Uint8.getFrom(iterator) entity = backend.entityGroup.getEntity(id) killed = net.Boolean.getFrom(iterator) if entity is not None: if killed: # The boolean indicates that the entity was not only deleted, it was killed. Also, let the entity know this was a remote delete packet. entity.kill(backend.aiWorld, backend.entityGroup, False) else: entity.delete(backend.entityGroup, False, False) rebroadcast = True elif type == constants.PACKET_REQUESTSPAWNPACKET: self.clientSpawnPacketRequests.append( (net.Uint8.getFrom(iterator), sender)) rebroadcast = False elif type == constants.PACKET_SETUP: if net.netMode == net.MODE_CLIENT: messenger.send("client-setup", [iterator]) else: return False rebroadcast = False elif type == constants.PACKET_CHAT: # Username and message messenger.send("chat-incoming", [ net.String.getFrom(iterator), net.String.getFrom(iterator) ]) rebroadcast = True elif type == constants.PACKET_ENDMATCH: engine.log.info("Received match end packet.") messenger.send("end-match", [iterator]) rebroadcast = True elif type == constants.PACKET_NEWCLIENT: # Sender address and username messenger.send( "server-new-connection", [sender, net.String.getFrom(iterator)]) rebroadcast = False elif type == constants.PACKET_DISCONNECT: engine.log.info( net.addressToString(sender) + " disconnected.") messenger.send("disconnect", [sender]) rebroadcast = False elif type == constants.PACKET_SERVERFULL: messenger.send("server-full") elif type == constants.PACKET_CONFIRMREGISTER: messenger.send("lobby-confirm-register") rebroadcast = False elif type == constants.PACKET_EMPTY: rebroadcast = False elif type == constants.PACKET_CLIENTREADY: rebroadcast = False messenger.send("client-ready", [sender]) elif type == constants.PACKET_NEWCLIENTNOTIFICATION: address = net.String.getFrom(iterator) port = net.Uint16.getFrom(iterator) # Make sure we get all the data out of the packet to ensure proper processing. # This packet has already been handled by the NetContext. rebroadcast = False elif type == constants.PACKET_ENTITYCHECKSUM: # Number of active entities we're supposed to have checksum = net.Uint8.getFrom(iterator) if net.netMode == net.MODE_CLIENT and checksum != len([ x for x in list(backend.entityGroup.entities.values( )) if x.active and x.getId() < 256 ]): # We don't have the right number of entities p = net.Packet() p.add(net.Uint8(constants.PACKET_REQUESTENTITYLIST)) net.context.send(p, sender) engine.log.info( "Entity checksum failed. Requesting full entity list." ) rebroadcast = False elif type == constants.PACKET_REQUESTENTITYLIST: p = net.Packet() p.add(net.Uint8(constants.PACKET_ENTITYLIST)) entityList = [ x for x in list(backend.entityGroup.entities.values()) if x.active and x.getId() < 256 ] p.add(net.Uint8(len(entityList))) for entity in entityList: p.add(net.Uint8(entity.getId())) net.context.send(p, sender) engine.log.info("Sending entity list to " + net.addressToString(sender)) rebroadcast = False elif type == constants.PACKET_ENTITYLIST: total = net.Uint8.getFrom(iterator) entities = [] missingEntities = [] for _ in range(total): id = net.Uint8.getFrom(iterator) if id not in list(backend.entityGroup.entities.keys()): missingEntities.append(id) entities.append(id) # Delete any extra entities, assuming they aren't ones that # we just spawned on our end. for entity in (x for x in list( backend.entityGroup.entities.values()) if x.active and x.getId() < 256): if entity.getId( ) not in entities and engine.clock.time - entity.spawnTime > 5.0: entity.delete(backend.entityGroup, False, False) if len(missingEntities) > 0: # Request spawn packets for any missing entities p = net.Packet() for id in missingEntities: p.add( net.Uint8(constants.PACKET_REQUESTSPAWNPACKET)) p.add(net.Uint8(id)) self.requestedEntitySpawns[id] = engine.clock.time engine.log.info( "Sending request for missing entity spawn packet. Entity ID: " + str(id)) net.context.send(p, sender) rebroadcast = False else: rebroadcast = False except AssertionError: engine.log.warning("Packet iteration failed. Discarding packet.") rebroadcast = False return rebroadcast
def __gotHouse(self, db, retcode): assert (self.notify.debug( "__gotHouse(%s, %s): %s" % (list(db.values.keys()), retcode, self.doId))) if retcode != 0: self.notify.warning("House %s for avatar %s does not exist!" % (self.av.houseId, self.av.doId)) self.sendCatalog(0) return atticItems = [] atticWallpaper = [] atticWindows = [] interiorItems = [] dg = db.values.get('setAtticItems') if dg: di = PyDatagramIterator(dg) blob = di.getString() atticItems = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Customization) dg = db.values.get('setAtticWallpaper') if dg: di = PyDatagramIterator(dg) blob = di.getString() atticWallpaper = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Customization) dg = db.values.get('setAtticWindows') if dg: di = PyDatagramIterator(dg) blob = di.getString() atticWindows = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Customization) dg = db.values.get('setInteriorItems') if dg: di = PyDatagramIterator(dg) blob = di.getString() interiorItems = CatalogItemList.CatalogItemList( blob, store=CatalogItem.Location | CatalogItem.Customization) # Finally we're ready to tell the user what he needs to know. numAtticItems = len(atticItems) + len(atticWallpaper) + len( atticWindows) numHouseItems = numAtticItems + len(interiorItems) self.sendCatalog(numHouseItems)
class MyApp(ShowBase): uname = None 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') def sendRequest101(self): 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 def receiveResponse101(self, task): while self.cReader.dataAvailable(): datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): self.myIterator = PyDatagramIterator(datagram) print "<-Server response:" print self.myIterator.getUint16() self.msg = self.myIterator.getUint32() self.l = self.myIterator.getUint32() if self.msg is not None: if self.l is not 0: for x in range(0, self.l): print self.myIterator.getString() print self.myIterator.getUint32() print self.myIterator.getUint32() print self.msg, " received" #raw_input("Press Enter to continue...") self.received = 0 taskMgr.remove('Login') #1-Character creatopm #taskMgr.add(self.sendRequest104, 'CharacterCreation') #2-heartbeat of playgame after login MyApp.sendRequest113(self) return task.again # LOGIN Request End # CHARACTER CREATION Starts def sendRequest104(self, task): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram = PyDatagram() prot = 104 cname = raw_input('Character Name :') faction_id_104 = raw_input('press 0 for Red Or 1 for Blue ? :') classType_104 = raw_input('press 0 for Axe Or 1 for Sword ? :') myPyDatagram.addUint16(prot) myPyDatagram.addString(cname) myPyDatagram.addUint32(faction_id_104) myPyDatagram.addUint32(classType_104) self.cWriter.send(myPyDatagram, self.connection) print "104 sent" self.received = 0 taskMgr.add(self.receiveResponse104, "characterresponse") def receiveResponse104(self, task): while self.cReader.dataAvailable(): datagram = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram): self.myIterator1 = PyDatagramIterator(datagram) print '------' print self.myIterator1.getUint16() self.msg = self.myIterator1.getUint32() if self.msg is not None: print "<-Server response:" print self.msg, " received" raw_input("Press Enter to continue...") self.received = 0 taskMgr.remove('CharacterCreation') taskMgr.add(self.sendRequest106, 'move') return task.again #CHARACTER CREATION Ends # Move Starts def sendRequest106(self, task): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram106 = PyDatagram() prot = 106 xpos = raw_input('X Position :') ypos = raw_input('Y Position :') zpos = raw_input('Z Position :') hpos = raw_input('Heading (0 to 360):') ismoving = raw_input('Moving ? -- 0 for NO , 1 for YES :') myPyDatagram106.addUint16(prot) myPyDatagram106.addUint32(xpos) myPyDatagram106.addUint32(ypos) myPyDatagram106.addUint32(zpos) myPyDatagram106.addUint32(hpos) myPyDatagram106.addUint32(ismoving) self.cWriter.send(myPyDatagram106, self.connection) self.received = 0 taskMgr.add(self.receiveResponse106, "characterresponse") def receiveResponse106(self, task): while self.cReader.dataAvailable(): datagram6 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram6): myIterator = PyDatagramIterator(datagram6) print myIterator.getUint16() msg = myIterator.getString() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() print myIterator.getUint32() print myIterator.getUint32() print myIterator.getUint32() print myIterator.getUint32() raw_input("Press Enter to continue...") self.received = 1 # Attack #raw_input("Press Enter to continue...") taskMgr.add(self.sendRequest108, 'health') return task.again #Move Ends #Change Health Starts def sendRequest108(self, task): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram108 = PyDatagram() prot = 108 change_Health = raw_input('Change in health (-100 to 100):') myPyDatagram108.addUint16(prot) myPyDatagram108.addUint32(change_Health) self.cWriter.send(myPyDatagram108, self.connection) self.received = 0 taskMgr.add(self.receiveResponse108, "healthresponse") def receiveResponse108(self, task): while self.cReader.dataAvailable(): datagram8 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram8): myIterator = PyDatagramIterator(datagram8) print myIterator.getUint16() msg = myIterator.getString() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() self.received = 1 # CP State raw_input("Press Enter to continue...") taskMgr.add(self.sendRequest107, 'attack') #Change Health Ends return task.again # Attack Starts def sendRequest107(self, task): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram107 = PyDatagram() prot = 107 attackId = raw_input('Attack Id (0 or 1):') myPyDatagram107.addUint16(prot) myPyDatagram107.addUint32(attackId) self.cWriter.send(myPyDatagram107, self.connection) #print " sent" self.received = 0 taskMgr.add(self.receiveResponse108, "attackresponse") def receiveResponse107(self, task): while self.cReader.dataAvailable(): datagram7 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram7): myIterator = PyDatagramIterator(datagram7) print myIterator.getUint16() msg = myIterator.getString() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() raw_input("Press Enter to continue...") self.received = 1 # Change Health taskMgr.add(self.sendRequest112, 'CP Capture') return task.again #Attack Ends #CP Capture Starts def sendRequest112(self, task): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram112 = PyDatagram() prot = 112 CP_id = raw_input('Control Point ID (1 to 5): ') faction_id = raw_input('press 0 for Red Or 1 for Blue ? :') myPyDatagram112.addUint16(prot) myPyDatagram112.addUint32(CP_id) myPyDatagram112.addUint32(faction_id) self.cWriter.send(myPyDatagram112, self.connection) #print " sent" self.received = 0 taskMgr.add(self.receiveResponse112, "CPCaptureRes") def receiveResponse112(self, task): while self.cReader.dataAvailable(): datagram12 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram12): myIterator = PyDatagramIterator(datagram12) print myIterator.getUint16() msg = myIterator.getUint32() if msg is not None: print "<-Server response:" print msg print myIterator.getUint32() raw_input("Press Enter to continue...") self.received = 1 #HeartBeat #raw_input("Press Enter to continue...") #taskMgr.add(self.communicate105, 'chat') #CP Capture Ends # CHAT Starts def communicate105(self, task): #print "communicate" self.sendRequest105() self.receiveResponse105(task) return task.again def sendRequest105(self): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram105 = PyDatagram() prot = 105 chat = raw_input('Insert Chat Message :') myPyDatagram105.addUint16(prot) myPyDatagram105.addString(chat) self.cWriter.send(myPyDatagram105, self.connection) print " sent" self.received = 0 def receiveResponse105(self, task): print "<-Server response:" while self.cReader.dataAvailable(): datagram5 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram5): myIterator = PyDatagramIterator(datagram5) print myIterator.getUint16() msg = myIterator.getUint16() print msg, " received" if msg is not None: raw_input("Press Enter to continue...") self.received = 1 # Move raw_input("Press Enter to continue...") taskMgr.add(self.communicate111, 'CP state') #CHAT Ends #CP State Starts def communicate111(self, task): #print "communicate" self.sendRequest111() self.receiveResponse111(task) return task.again def sendRequest111(self): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram111 = PyDatagram() prot = 111 CP_id = raw_input('Control Point ID (1 to 5): ') CP_state = raw_input('Control Point state (1 red, 2 blue, 3 purple): ') myPyDatagram111.addUint16(prot) myPyDatagram111.addUint16(CP_id) myPyDatagram111.addUint16(CP_state) self.cWriter.send(myPyDatagram111, self.connection) print " sent" self.received = 0 def receiveResponse111(self, task): print "<-Server response:" while self.cReader.dataAvailable(): datagram11 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram11): myIterator = PyDatagramIterator(datagram11) print myIterator.getUint16() msg = myIterator.getUint16() print msg, " received" if msg is not None: raw_input("Press Enter to continue...") self.received = 1 # CP Capture raw_input("Press Enter to continue...") taskMgr.add(self.communicate102, 'Logout') #CP State Ends # LOGOUT Starts def communicate102(self, task): #print "communicate" self.sendRequest102() self.receiveResponse102(task) return task.again def sendRequest102(self): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram102 = PyDatagram() prot = 102 myPyDatagram102.addUint16(prot) self.cWriter.send(myPyDatagram102, self.connection) print " sent" self.received = 0 def receiveResponse102(self, task): print "<-Server response:" while self.cReader.dataAvailable(): datagram2 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram2): myIterator = PyDatagramIterator(datagram2) print myIterator.getUint16() msg = myIterator.getUint16() print msg, " received" if msg is not None: raw_input("Press Enter to continue...") self.received = 1 # Register raw_input("Press Enter to continue...") taskMgr.add(self.communicate301, 'Heartbeat') #LOGOUT Ends #HeartBeat Starts def communicate301(self): #print "communicate" self.sendRequest301() self.receiveResponse301() #return task.again; def sendRequest301(self, task): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram301 = PyDatagram() prot = 301 myPyDatagram301.addUint16(prot) self.cWriter.send(myPyDatagram301, self.connection) self.received = 0 return task.again def receiveResponse301(self): while self.cReader.dataAvailable(): datagram301 = NetDatagram() # Retrieve the contents of the datagram. if self.cReader.getData(datagram301): myIterator = PyDatagramIterator(datagram301) p = myIterator.getUint16() if p == 213: un = myIterator.getString() cname = myIterator.getString() ctype = myIterator.getUint32() cteam = myIterator.getUint32() if un == MyApp.uname: abc = 'abc' else: print cname + ' just joined a game......!! hurray' #print msg, " received" self.received = 1 #HeartBeat Ends #heartbeat def sendRequest113(self): if (self.received): print "->Client request:" # Send a request to the server myPyDatagram113 = PyDatagram() prot = 113 myPyDatagram113.addUint16(prot) print MyApp.uname + '-------' if MyApp.uname == 'chintan': myPyDatagram113.addUint32(18) elif MyApp.uname == 'paras': myPyDatagram113.addUint32(35) else: myPyDatagram113.addUint32(3) self.cWriter.send(myPyDatagram113, self.connection) self.received = 0 #taskMgr.add(self.updateRoutine,'update113') #taskMgr.doMethodLater(1,self.sendRequest301,'HeatBeat') MyApp.retrieve113(self) def retrieve113(self): taskMgr.add(self.updateRoutine, 'update113') taskMgr.doMethodLater(1, self.sendRequest301, 'HeatBeat') def updateRoutine(self, task): self.receiveResponse301() return task.again