def resendLoginCookie(self): cr = self.cr datagram = PyDatagram() datagram.addUint16(CLIENT_SET_SECURITY) self.__addLoginCookie(datagram) self.__addTokenType(datagram) cr.send(datagram)
def resendPlayToken(self): cr = self.cr datagram = PyDatagram() datagram.addUint16(CLIENT_SET_SECURITY) self._LoginTTAccount__addPlayToken(datagram) self._LoginTTAccount__addTokenType(datagram) cr.send(datagram)
def sendMagicWord(self, word, targetId): invokerId = self.air.getAvatarIdFromSender() invoker = self.air.doId2do.get(invokerId) if not 'DistributedToonAI' in str(self.air.doId2do.get(targetId)): self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['Target is not a toon object!']) return if not invoker: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing invoker']) return if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS: self.air.writeServerEvent('suspicious', invokerId, 'Attempted to issue magic word: %s' % word) dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(102) dg.addString('Magic Words are reserved for administrators only!') self.air.send(dg) return target = self.air.doId2do.get(targetId) if not target: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing target']) return response = spellbook.process(invoker, target, word) if response: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [response]) self.air.writeServerEvent('magic-word', invokerId, invoker.getAdminAccess(), targetId, target.getAdminAccess(), word, response)
def setObjectZone(self, owner, object, zoneId): if object.zoneId == zoneId: # No change. return oldZoneId = object.zoneId self.objectsByZoneId[object.zoneId].remove(object) if not self.objectsByZoneId[object.zoneId]: del self.objectsByZoneId[object.zoneId] owner.objectsByZoneId[object.zoneId].remove(object) if not owner.objectsByZoneId[object.zoneId]: del owner.objectsByZoneId[object.zoneId] object.zoneId = zoneId self.objectsByZoneId.setdefault(zoneId, set()).add(object) owner.objectsByZoneId.setdefault(zoneId, set()).add(object) self.updateClientInterestZones(owner) # Any clients that are listening to oldZoneId but not zoneId # should receive a disable message: this object has just gone # out of scope for you. datagram = PyDatagram() datagram.addUint16(OBJECT_DISABLE_CMU) datagram.addUint32(object.doId) for client in self.zonesToClients[oldZoneId]: if client != owner: if zoneId not in client.currentInterestZoneIds: self.cw.send(datagram, client.connection) self.needsFlush.add(client)
def createObject(self, objectType): values = {} for key, value in values.items(): values[key] = PyDatagram(str(value)) context = self.air.dbObjContext self.air.dbObjContext += 1 self.air.dbObjMap[context] = self self.createObjType = objectType dg = PyDatagram() dg.addServerHeader( DBSERVER_ID, self.air.ourChannel, DBSERVER_CREATE_STORED_OBJECT) dg.addUint32(context) dg.addString('') dg.addUint16(objectType) dg.addUint16(len(values)) for field in values.keys(): dg.addString(field) for value in values.values(): dg.addString(value.getMessage()) self.air.send(dg)
def handle_create_account_request(self, netmgr, connection, username, password): file_path = self.directory_path + str(username) + self.database_file_ext self.netmgr = netmgr data = { "account_name": str(username), "account_password": str(password) } if os.path.exists(file_path): print ("Could not create account with username %s because it already exists." % username) return with open(file_path, 'w+') as file: json.dump(data, file) if os.path.exists(file_path): datagram = PyDatagram() datagram.addUint16(REQUEST_FOR_REGISTER_RESP) datagram.addUint8(0) datagram.addString("Successfully registered account! Now try to login!") self.netmgr.send_response(connection, datagram) print ("Database: Client %s Successfully registered an account with the name %s" % (connection, username)) else: datagram = PyDatagram() datagram.addUint16(REQUEST_FOR_REGISTER_RESP) datagram.addUint8(1) datagram.addString("Failed to create account, please contact customer support!") self.netmgr.send_response(connection, datagram) return file.close()
def sendGameStatus(): px,py,pz = ballBody.getPosition() prot = ballBody.getRotation() r1,r2,r3,r4 = row1.getZ(), row2.getZ(), row3.getZ(), row4.getZ() o1,o2,o3,o4 = rrow1.getZ(), rrow2.getZ(), rrow3.getZ(), rrow4.getZ() rot = [None]*4 for i in range(0,4): rot[i] = kicker[i].getH() status = PyDatagram() status.addUint16(PACKET_SET) status.addFloat64(px) status.addFloat64(py) status.addFloat64(pz) for r in range(9): #just to be explicit status.addFloat64(prot[i]) status.addFloat64(r1) status.addFloat64(r2) status.addFloat64(r3) status.addFloat64(r4) status.addFloat64(o1) status.addFloat64(o2) status.addFloat64(o3) status.addFloat64(o4) for i in range(0,4): status.addFloat64(rot[i]) toAll(status, activeConnections)
def disconnect(task): dg = PyDatagram() dg.addServerHeader(10, simbase.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(154) dg.addString('Toontown Fellowship is now closed for maintenance.') simbase.air.send(dg) return Task.done
def sendMove(mx, my): move = PyDatagram() move.addUint16(PACKET_MOVE) sgn = (mode == MODE_2P or MY_POSITION>1) and -1 or 1 move.addFloat64(sgn*mx) move.addFloat64(sgn*my) cWriter.send(move, serverConnection)
def doAuth(self, opcode, data, _client): """ Handle auth for a single client connecting """ ## Get the client id newClientId = data.getString() print "Server: New client connected -", newClientId self.server.serverState.lastJoinedClientId = newClientId # Create the player into the server players holder self.server.serverState.newClientPlayerObj(newClientId, _client) # Get all connected clientPlayers states and ids #for conn in self.connections: for client in self.clients: clId = self.clients[client].id clState = self.clients[client].state # Create buffer pkg = PyDatagram() # Add response pkg.addUint16(cmdToClient_authResponse) pkg.addString(clId) pkg.addString(str(clState.pos)) pkg.addString(str(clState.t)) self.networkMgr.tcpWriter.send(pkg, _client) # maybe add a if to check to update other players about the new guy # tell other connected players about the new player newClientState = self.clients[newClientId].state self.server.serverState.broadcastNewClient(newClientId, newClientState)
def close_connection(self, code, reason, connection): datagram = PyDatagram() datagram.addUint16(CLIENT_GO_GET_LOST) datagram.addUint16(int(code)) datagram.addString(str(reason)) self.cw.send(datagram, connection) self.remove_connection_instance(connection)
def requestAvatarInfo(self, avId): if avId == 0: return datagram = PyDatagram() datagram.addUint16(CLIENT_GET_FRIEND_LIST_EXTENDED) datagram.addUint16(1) datagram.addUint32(avId) base.cr.send(datagram)
def sendSetLocation(self, doId, parentId, zoneId): """ Called by b_setLocation """ dg = PyDatagram() dg.addUint16(CLIENT_OBJECT_LOCATION) dg.addUint32(doId) dg.addUint32(parentId) dg.addUint32(zoneId) self.send(dg)
def sendOffToons(self, game, zoneid): for avatar in self.station.avatars: pkg = PyDatagram() pkg.addUint16(STATION_HEAD_OFF) pkg.addUint32(avatar.doId) pkg.addString(game) pkg.addUint16(zoneid) base.sr.sendDatagram(pkg)
def route_message(self, di, datagram, reciever_channel, sender_channel): dg = PyDatagram() dg.addUint64(reciever_channel) dg.addUint64(sender_channel) dg.addUint16(di.getUint16()) dg.appendData(di.getRemainingBytes()) self.cw.send(dg, self.interface.registeredParticipants[reciever_channel]) dg.clear()
def moveRalph(self): pkg = PyDatagram() pkg.addUint16(114) pkg.addFloat32(self.ralph.getX()) pkg.addFloat32(self.ralph.getY()) pkg.addFloat32(self.ralph.getZ()) pkg.addFloat32(self.ralph.getH()) self.cWriter.send(pkg,self.connection)
def pingTask(task): if (task.frame % 1000) > 0: #determine network delay every now and then (every 1000 frames) return Task.cont ping = PyDatagram() ping.addUint16(PACKET_PING) ping.addFloat64(time.time()) toAll(ping, activeConnections) return Task.cont
def genericPacket(key, packetCount=0): myPyDatagram = PyDatagram() myPyDatagram.addUint8(key) myPyDatagram.addUint8(packetCount) myPyDatagram.addUint8(0) myPyDatagram.addUint16(0) myPyDatagram.addUint16(0) return myPyDatagram
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 locateAvatar(self, zoneId): if self.av: dg = PyDatagram() dg.addUint16(CLIENT_OBJECT_LOCATION) dg.addUint32(self.av.doId) dg.addUint32(self.timeManager.doId) dg.addUint32(zoneId) self.send(dg)
def ban(self, banner, target, time): dg = PyDatagram() dg.addServerHeader(target.GetPuppetConnectionChannel(target.doId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(155) dg.addString('You were kicked by a moderator!') self.air.send(dg) self.sendUpdate("banUD", [banner, target.DISLid, time])
def moveRequest(self, x, y, z, h, isMoving): pkg = PyDatagram() pkg.addUint16(106) pkg.addFloat32(x) pkg.addFloat32(y) pkg.addFloat32(z) pkg.addFloat32(h) pkg.addUint16(isMoving) return pkg
def move(self): self.player.x += 1 pkg = PyDatagram() pkg.addUint16(114) pkg.addFloat32(self.player.x) pkg.addFloat32(self.player.y) pkg.addFloat32(self.player.z) pkg.addFloat32(self.player.rotation) self.cWriter.send(pkg,self.connection)
def genBasicData(self, proto): myPyDatagram = PyDatagram() myPyDatagram.addUint8(proto) myPyDatagram.addUint8(self.packetCount) myPyDatagram.addUint8(0) myPyDatagram.addUint16(0) myPyDatagram.addUint16(0) self.packetCount += 1 return myPyDatagram
def checkReset(): global lastResetPress lastResetPress = time.time() reset = PyDatagram() #send a reset request to partner reset.addUint16(PACKET_RESET) if role==ROLE_CLIENT: cWriter.send(reset, serverConnection) elif role == ROLE_SERVER and not isResetConfirmed(): toAll(reset, activeConnections)
def sendDisconnectClient(self, di, connection, errorCode, reason): datagram = PyDatagram() datagram.addUint16(CLIENT_GO_GET_LOST) datagram.addUint16(errorCode) datagram.addString(reason) self.cw.send(datagram, connection) datagram.clear() self.handleClientDisconnected(di, connection)
def handleAuth(self, opcode, data, client): """ Handle auth and player login. NOTE: THIS IS REALLY SIMPLE FOR NOW Add something to check if the user is already logged in """ # Get the data the client sent. clientUser = data.getString() clientPass = data.getString() # Flag to be send back after serverside auth flag = None userpass = False loginTries = 0 # Not thought out now, will return to it later... # Get the data from DB try: # Here we can add the player to the PLAYERS{} by using a player # ID or something details = [] details = Database.getAccountData(clientUser, clientPass) except: print "Can't connected to ACCOUNT DATABASE" # Will make some other checks later... this is just good for now.. if details == None: flag = 2 print "Player: ", clientUser, " Doesn't exist! or Incorrect!" loginTries += 1 # Check if the password/username match elif clientPass == details[2] and clientUser == details[1]: print details userpass = True self.network.base.PLAYERS[details[0]] = Player(self, details[0], details[1]) print "Player: ", details[1], " Logged in, ID: ", details[0] flag = 1 else: userpass = False print "Player: ", clientUser, " login incorrect" loginTries += 1 flag = 2 # Create buffer pkg = PyDatagram() # Add response pkg.addUint16(SMSG_AUTH_RESPONSE) # Add the flag pkg.addUint16(flag) # Send the packet self.network.tcpWriter.send(pkg, client)
def sendClientRemoveInterest(self, di, connection, handle, contextId): datagram = PyDatagram() datagram.addUint16(CLIENT_REMOVE_INTEREST) datagram.addUint16(handle) datagram.addUint32(contextId) client_channel = self.connectionToChannel[connection] if client_channel in self.registeredClients: self.cw.send(datagram, connection)
def sendClientAddInterest(self, di, connection, handle, contextId, parentId, zoneId): datagram = PyDatagram() datagram.addUint16(CLIENT_DONE_INTEREST_RESP) datagram.addUint16(handle) datagram.addUint32(contextId) client_channel = self.connectionToChannel[connection] if client_channel in self.registeredClients: self.cw.send(datagram, connection)
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.REQ_HEARTBEAT) self.cWriter.send(pkg, self.connection) # self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log("Bad [" + str(Constants.RAND_STRING) + "] Int Request")
def setAllowClientSend(self, avId, distObj, fieldNameList=[]): dg = PyDatagram() dg.addServerHeader(distObj.GetPuppetConnectionChannel(avId), self.ourChannel, CLIENTAGENT_SET_FIELDS_SENDABLE) fieldIds = [] for fieldName in fieldNameList: field = distObj.dclass.getFieldByName(fieldName) if field: fieldIds.append(field.getNumber()) dg.addUint32(distObj.getDoId()) dg.addUint16(len(fieldIds)) for fieldId in fieldIds: dg.addUint16(fieldId) self.send(dg)
def rpc_kickChannel(self, channel, code, reason): """ Summary: Kicks any client whose Client Agent is subscribed to the provided [channel]. Parameters: [int channel] = The channel to kick. [int code] = The code for the kick. [str reason] = The reason for the kick. """ datagram = PyDatagram() datagram.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(code) datagram.addString(reason) self.air.send(datagram)
def banId(id, reason): """ Ban and Kick the short id from the game server. """ target = simbase.air.doId2do.get(100000000 + id) if target == spellbook.getInvoker(): return "You can't ban yourself!" simbase.air.banManager.ban(target.doId, reason) datagram = PyDatagram() datagram.addServerHeader(target.GetPuppetConnectionChannel(target.doId), simbase.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(155) datagram.addString( 'You were banned by a moderator for the following reason: %s' % reason) simbase.air.send(datagram) return "Kicked and Banned %s from the game server!" % target.getName()
def sendMagicWord(self, word, targetId, execute): invokerId = self.air.getAvatarIdFromSender() invoker = self.air.doId2do.get(invokerId) if not invoker: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing invoker']) return if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS: self.air.writeServerEvent( 'suspicious', avId=invokerId, issue='Attempted to issue magic word: %s' % word) dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(126) dg.addString('Magic Words are reserved for administrators only!') self.air.send(dg) return target = self.air.doId2do.get(targetId) if not target: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing target']) return if execute: response = spellbook.process(invoker, target, word) if response[0]: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [response[0]]) else: response = ('Client MW executed.', ) from otp.avatar.DistributedPlayerAI import DistributedPlayerAI targetAccess = 0 if not isinstance( target, DistributedPlayerAI) else target.getAdminAccess() self.air.writeServerEvent('magic-word', invokerId=invokerId, invokerAccess=invoker.getAdminAccess(), targetId=targetId, targetAccess=targetAccess, word=word, response=response[0])
def queryObject(self, databaseId, doId, callback, dclass=None, fieldNames=()): """ Query object `doId` out of the database. On success, the callback will be invoked as callback(dclass, fields) where dclass is a DCClass instance and fields is a dict. On failure, the callback will be invoked as callback(None, None). """ # Save the callback: ctx = self.air.getContext() self._callbacks[ctx] = callback self._dclasses[ctx] = dclass # Generate and send the datagram: dg = PyDatagram() if not fieldNames: dg.addServerHeader(databaseId, self.air.ourChannel, DBSERVER_OBJECT_GET_ALL) else: # We need a dclass in order to convert the field names into field IDs: assert dclass is not None if len(fieldNames) > 1: dg.addServerHeader(databaseId, self.air.ourChannel, DBSERVER_OBJECT_GET_FIELDS) else: dg.addServerHeader(databaseId, self.air.ourChannel, DBSERVER_OBJECT_GET_FIELD) dg.addUint32(ctx) dg.addUint32(doId) if len(fieldNames) > 1: dg.addUint16(len(fieldNames)) for fieldName in fieldNames: field = dclass.getFieldByName(fieldName) if field is None: self.notify.error('Bad field named %s in query for' ' %s object' % (fieldName, dclass.getName())) dg.addUint16(field.getNumber()) self.air.send(dg)
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 auth_REQ(self, user, passw): """ Handle the login packet to server. """ # Create the buffer pkg = PyDatagram() # Add the opcode pkg.addUint16(CMSG_AUTH) # Add the user and pass Details # This is kept really simple pkg.addString(user) pkg.addString(passw) # Send the packet self.network.tcpWriter.send(pkg, self.tcpConn)
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 send(self, args=[]): try: # print "sender's id:", args[0] # print "receiver's id:", args[1] pkg = PyDatagram() pkg.addUint16(Constants.CMSG_CHAT_ONE) pkg.addInt32(args[0]) # sender's id pkg.addInt32(args[1]) # receiver's id pkg.addString(args[2]) # message self.cWriter.send(pkg, self.connection) # self.log('Sent [' + str(Constants.CMSG_CHAT_ONE) + '] Chat Request') except: self.log('Bad [' + str(Constants.CMSG_CHAT_ONE) + '] Chat Request') print_exc()
def sendLoginMsg(self): """ Send a message to the server with our loginName """ DISLID = ConfigVariableInt('fake-DISL-PlayerAccountId',0).getValue() if not DISLID: NameStringId = ("DISLID_%s" % (self.loginName)) DISLID = ConfigVariableInt(NameStringId, 0).getValue() cr=self.cr # Time to send a login message datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_LOGIN) # Add login name datagram.addString(self.loginName) # Add our IP address if cr.connectMethod != cr.CM_HTTP: datagram.addUint32(cr.tcpConn.getAddress().getIp()) else: # Actually, using the OpenSSL library we don't know our # own IP address. But no one really cares anyway. datagram.addUint32(0) # Add the UDP port we will be listening on. (Bogus for now) datagram.addUint16(5150) # Add the Server Version ID datagram.addString(cr.serverVersion) # Add the dc file hash datagram.addUint32(cr.hashVal) # Add password datagram.addString(self.password) # Add create flag datagram.addBool(self.createFlag) # Add the download verification string. datagram.addString(cr.validateDownload) # And the magic word enable string. datagram.addString(cr.wantMagicWords) # And our dev fake DISL account ID datagram.addUint32(DISLID) # Whether or not to enable OTP_WHITELIST datagram.addString(ConfigVariableString('otp-whitelist',"YES").getValue()) # Send the message cr.send(datagram)
def readerPollOnce(self): try: return AstronInternalRepository.readerPollOnce(self) except (SystemExit, KeyboardInterrupt): raise except Exception as e: if self.getAvatarIdFromSender( ) > 100000000: # If an avatar is sending, boot them dg = PyDatagram() dg.addServerHeader(self.getMsgSender(), self.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(420) dg.addString( 'You were disconnected to prevent a district reset.') self.send(dg) self.writeServerEvent('EXCEPTION-POTENTIAL-CRASH', self.getAvatarIdFromSender(), self.getAccountIdFromSender(), repr(e), traceback.format_exc()) self.notify.warning('EXCEPTION-POTENTIAL-CRASH: %s (%s)' % (repr(e), self.getAvatarIdFromSender())) print traceback.format_exc() sys.exc_clear() import os if os.getenv('DISTRICT_NAME', 'Test Canvas') == "Test Canvas": return 1 from raven import Client from os.path import expanduser errorReporter = Client( 'https://*****:*****@sentry.io/189240' ) errorReporter.tags_context({ 'district_name': os.getenv('DISTRICT_NAME', 'UNDEFINED'), 'AVID_SENDER': self.getAvatarIdFromSender(), 'ACID_SENDER': self.getAccountIdFromSender(), 'homedir': expanduser('~'), 'CRITICAL': 'False' }) errorReporter.captureException() return 1
def handleNewAvatar(self, entry): intoNP = entry.getIntoNodePath() toonNP = intoNP.getParent() for key in self.cr.doId2do.keys(): val = self.cr.doId2do[key] if val.__class__.__name__ == 'DistributedToon': if val.getKey() == toonNP.getKey(): if val.zoneId == 30: if self.station.getAvailableSlots() > 0 and val not in self.station.avatars: availableSlot = self.station.getAnAvailableSlot() pkg = PyDatagram() pkg.addUint16(STATION_SLOTS_OPEN) pkg.addUint8(availableSlot) pkg.addUint32(self.station.doId) pkg.addUint32(val.doId) base.sr.sendDatagram(pkg) self.gotNewAvatar(val)
def send(self, args): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_ENTER_GAME_LOBBY) #pkg.addString(args[0]) #username #pkg.addUint16(args[1]) #gameId #pkg.addUint16(args[2]) #lobbyId pkg.addUInt16(args) #room id self.cWriter.send(pkg, self.connection) print "RequestEnterGameLobby sent" except: self.log('Bad [' + str(Constants.CMSG_ENTER_GAME_LOBBY) + '] Login Request') print_exc()
def readerPollOnce(self): try: return AstronInternalRepository.readerPollOnce(self) except SystemExit as KeyboardInterrupt: raise except Exception as e: if self.getAvatarIdFromSender() > 100000000: dg = PyDatagram() dg.addServerHeader(self.getMsgSender(), self.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(166) dg.addString('You were disconnected to prevent a district reset.') self.send(dg) self.writeServerEvent('INTERNAL-EXCEPTION', self,getAvatarIdFromSender(), self.getAccountIdFromSender, repr(e), traceback.format_exc()) self.notify.warning('INTERNAL-EXCEPTION: {0} ({1})'.format(repr(e), self.getAvatarIdFromSender)) print(traceback.format_exc) sys.exc_clear() return 1
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_MOVE) pkg.addFloat32(args[0]) #x pkg.addFloat32(args[1]) #y pkg.addFloat32(args[2]) #z pkg.addFloat32(args[3]) #h pkg.addInt32(args[4]) #isMoving self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_FLOAT) + '] Float Request') except: self.log('Bad [' + str(Constants.CMSG_MOVE) + '] Move Request') print_exc()
def getFields(self, fields): # Get a unique context for this query and associate ourselves # in the map. context = self.air.dbObjContext self.air.dbObjContext += 1 self.air.dbObjMap[context] = self dg = PyDatagram() dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_GET_STORED_VALUES) dg.addUint32(context) dg.addUint32(self.doId) dg.addUint16(len(fields)) for f in fields: dg.addString(f) self.air.send(dg)
def sendMagicWord(self, word, targetId): invokerId = self.air.getAvatarIdFromSender() invoker = self.air.doId2do.get(invokerId) if not invoker: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing invoker']) return if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS: self.air.writeServerEvent( 'suspicious', invokerId, 'Attempted to issue magic word: %s' % word) dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(126) dg.addString('Magic Words are reserved for administrators only!') self.air.send(dg) return target = self.air.doId2do.get(targetId) if not target: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing target']) return if not hasattr(target, 'isNPC'): self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['invalid target']) return if target.isNPC(): self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['invalid target']) return response = spellbook.process(invoker, target, word) if response: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [response]) self.air.writeServerEvent('magic-word', invokerId, invoker.getAdminAccess(), targetId, target.getAdminAccess(), word, response)
def dg_update_name(pid, name): """ Call when you want to update your name @param pid: player ID @type pid: int @param name: new name @type name: string @return: the datagram you need to send @rtype: datagram """ if pid is not None: dg = PyDatagram() dg.addUint8(UPDATE_NAME) dg.addUint16(pid) dg.addString(name) return dg else: print("!! TRIED TO SEND DATAGRAM WITH NO PID !!")
def sendUserInput(self, inputArr = [], *args): pkg = PyDatagram() pkg.addUint16(CLIENT_INPUT) pkg.addUint64(self.myClock) pkg.addBool(inputArr[0]) pkg.addBool(inputArr[1]) pkg.addBool(inputArr[2]) pkg.addBool(inputArr[3]) pkg.addBool(inputArr[4]) if inputArr[4]: pkg.addFloat32(inputArr[5]) pkg.addFloat32(inputArr[6]) pkg.addFloat32(inputArr[7]) pkg.addString(str(inputArr[8])) pkg.addFloat32(self.gameEngine.players[self.id].playerNP.getH() % 360) pkg.addFloat32(self.gameEngine.players[self.id].playerSpine.getP() % 360) # Now lets send the whole thing... self.send(pkg)
def send(self, pos): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_MOVE) posNew = pos.split(",") pkg.addFloat32(float(posNew[0])) pkg.addFloat32(float(posNew[1])) pkg.addFloat32(float(posNew[2])) pkg.addFloat32(float(posNew[3])) pkg.addInt32(int(posNew[4])) self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log('Bad [' + str(Constants.CMSG_MOVE) + '] Int Request') print_exc()
def send(self, character=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_CREATE_CHARACTER) characterlist = character.split() # print "characterlist", characterlist # print "username ",characterlist[0] # print "charname ",characterlist[1] pkg.addString(characterlist[0]) pkg.addString(characterlist[1]) self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log('Bad [' + str(Constants.RAND_STRING) + '] Int Request') print_exc()
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_CREATE_CHARACTER) pkg.addUint16(args[0]) #TYPE pkg.addFloat32(args[1]) #x pos pkg.addFloat32(args[2]) #y pos pkg.addFloat32(args[3]) #z pos # print "RequestCreateCharacter - ", args[0], " x:", args[1], " y:", args[2]," z:", args[3] self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log('Bad [' + str(Constants.RAND_STRING) + '] Int Request') print_exc()
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 sendMagicWord(self, word, targetId): invokerId = self.air.getAvatarIdFromSender() invoker = self.air.doId2do.get(invokerId) target = self.air.doId2do.get(targetId) targets = spellbook.getTargets(word) if targets: if target is not None and target.__class__.__name__ not in targets: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [ 'Target is a %s object! Expected: %s' % (target.__class__.__name__, targets) ]) return if not invoker: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['Missing invoker!']) return if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS: self.air.writeServerEvent( 'suspicious', invokerId, 'Attempted to issue magic word: %s' % word) dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(126) dg.addString('Magic Words are reserved for administrators only!') self.air.send(dg) return if target is None: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['Missing target!']) return response = spellbook.process(invoker, target, word) if response: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [response]) self.air.writeServerEvent('magic-word', invokerId, invoker.getAdminAccess(), targetId, target.getAdminAccess(), word, response)
def resendPlayToken(self): """ Resends our playToken to the game server while still logged on. This is necessary when our playTaken has changed properties in-game, for instance when we enable chat. """ assert self.response is not None assert not self.response.hasKey('errorMsg') # Hey, there was an error assert "playToken" in self.__dict__ # Hey, there's no playToken. #...no error code in the response, so we have a play token. cr = self.cr datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_SET_SECURITY) self.__addPlayToken(datagram) self.__addTokenType(datagram) # Send the message cr.send(datagram)
def sendLoginMsg(self): cr = self.cr datagram = PyDatagram() if self.useTTSpecificLogin: datagram.addUint16(CLIENT_LOGIN_TOONTOWN) self.__addPlayToken(datagram) datagram.addString(cr.serverVersion) datagram.addUint32(cr.hashVal) self.__addTokenType(datagram) datagram.addString(cr.wantMagicWords) else: datagram.addUint16(CLIENT_LOGIN_2) self.__addPlayToken(datagram) datagram.addString(cr.serverVersion) datagram.addUint32(cr.hashVal) self.__addTokenType(datagram) datagram.addString(cr.validateDownload) datagram.addString(cr.wantMagicWords) cr.send(datagram)
def sendMagicWord(self, word, targetId): invokerId = self.air.getAvatarIdFromSender() invoker = self.air.doId2do.get(invokerId) if not isinstance(self.air.doId2do.get(targetId), DistributedToonAI): self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['Target is not a toon object!']) return if not invoker: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing invoker']) return now = time.strftime("%c") if invoker.getAdminAccess() < MINIMUM_MAGICWORD_ACCESS: self.air.writeServerEvent( 'suspicious', invokerId, 'Attempted to issue magic word: %s' % word) dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(invokerId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(126) dg.addString('Magic Words are reserved for administrators only!') self.air.send(dg) return target = self.air.doId2do.get(targetId) if not target: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', ['missing target']) return response = spellbook.process(invoker, target, word) if response: self.sendUpdateToAvatarId(invokerId, 'sendMagicWordResponse', [response]) self.air.writeServerEvent('magic-word', invokerId, invoker.getAdminAccess(), targetId, target.getAdminAccess(), word, response) with open("logs/mw/magic-words.txt", "a") as textFile: textFile.write("%s | %s : %s\n" % (now, invokerId, word)) print("%s | %s : %s\n" % (now, invokerId, word))
def createObject(self, objectType): # If we just want the default values for the new object's fields, # there's no need to specify any field values here. (Upon generation, # fields that are not stored in the database are assigned their # default values). # In the future, when creating an object in the DB, we may want # to provide values that differ from the default; this dict is # the place to put those values. # Note that the values in this dict must be specially formatted in # a datagram; I haven't sussed that out. See self.reload() and # AIDistUpdate.insertArg(). values = {} for key, value in list(values.items()): values[key] = PyDatagram(str(value)) # objectType is an integer that the DB uses to distinguish object # types, i.e. ToontownAIMsgTypes.DBSERVER_PET_OBJECT_TYPE assert type(objectType) is int # Get a unique context for this query and associate ourselves # in the map. context = self.air.dbObjContext self.air.dbObjContext += 1 self.air.dbObjMap[context] = self self.createObjType = objectType dg = PyDatagram() dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_CREATE_STORED_OBJECT) dg.addUint32(context) dg.addString('') dg.addUint16(objectType) dg.addUint16(len(values)) for field in list(values.keys()): dg.addString(field) for value in list(values.values()): dg.addString(value.getMessage()) self.air.send(dg)
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 send(self, forces): try: #print "Req Move: ", forces[3], forces[4], forces[5], forces[6], forces[7], forces[8] pkg = PyDatagram() pkg.addUint16(Constants.CMSG_MOVE) pkg.addFloat32(forces[0]) pkg.addFloat32(forces[1]) pkg.addFloat32(forces[2]) pkg.addFloat32(forces[3]) pkg.addFloat32(forces[4]) pkg.addFloat32(forces[5]) pkg.addFloat32(forces[6]) pkg.addFloat32(forces[7]) pkg.addFloat32(forces[8]) self.cWriter.send(pkg, self.connection) except: self.log('Bad [' + str(Constants.CMSG_MOVE) + '] Move Request')