def makeCommandStringDatagram(self, commandString): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_COMMAND_STRING) datagram.addString(commandString) return datagram
def WAIT(self, charid, direction): myPyDatagram = PyDatagram() myPyDatagram.addString('WAIT') myPyDatagram.addString(charid) # seem direction became str myPyDatagram.addUint8(int(direction)) self.cWriter.send(myPyDatagram, self.myConnection)
def ATTACK_SUCCESS(self, charid1, charid2, damages, player): myPyDatagram = PyDatagram() myPyDatagram.addString('ATTACK_SUCCESS') myPyDatagram.addString(charid1) myPyDatagram.addString(charid2) myPyDatagram.addUint8(damages) self.cWriter.send(myPyDatagram, player)
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 scoreDatagram(self): # Send the player's score myPyDatagram = PyDatagram() myPyDatagram.addUint8(END_MESSAGE) myPyDatagram.addString(self.playername) myPyDatagram.addInt32(self.carData.carlist[self.carData.index].deaths) return myPyDatagram
def process(self, data): it = PyDatagramIterator(data) mssgID = it.getUint8() if mssgID == 42: return None vel = it.getFloat32() z = it.getFloat32() x = it.getFloat32() y = it.getFloat32() checksum = it.getFloat32() #print "velocity:" , vel , #" Z position:" , z , " Checksum " , checksum newx = x zdiff = z - self.smiley.getZ() self.smiley.setPythonTag("velocity", vel + zdiff * 0.03) #self.smiley.setX(x) #self.smiley.setZ(z) #self.smiley.setY(y) data = PyDatagram() data.addUint8(0) data.addString("w") #change this to key being pressed forward data.addString("OH HI MARTK!!") return data
def sendChatMessage(self, message, target="all"): datagram = PyDatagram() datagram.addUint8(protocols.ClientMsgId.chatMsg) datagram.addString("server") datagram.addString(message) if target == "all": self.server.broadcast(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 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 characterCreationRequest(self, username, classType): pkg = PyDatagram() pkg.addUint16(104) pkg.addString(username) pkg.addUint16(0) pkg.addUint16(classType) return pkg
class World(DirectObject): #This class will control anything related to the virtual world def __init__(self): self.timeSinceLastUpdate = 0 def UpdateWorld(self,meClass,clientClass): #get the time since the last framerate self.elapsed = globalClock.getDt() #add it to the time since we last set our position to where the server thinks we are #add the elapsed time to the time since the last update sent to the server self.timeSinceLastUpdate += self.elapsed if (self.timeSinceLastUpdate > 0.1): self.datagram = PyDatagram() self.datagram.addString("positions") self.datagram.addFloat64(meClass.model.getX()) self.datagram.addFloat64(meClass.model.getY()) self.datagram.addFloat64(meClass.model.getZ()) self.datagram.addFloat64(meClass.model.getH()) self.datagram.addFloat64(meClass.model.getP()) self.datagram.addFloat64(meClass.model.getR()) try: clientClass.cWriter.send(self.datagram,clientClass.Connection) except: print "No connection to the server. You are in stand alone mode." return Task.done self.timeSinceLastUpdate = 0 return Task.cont
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 MOVED(self, charid, x, y, z, player): myPyDatagram = PyDatagram() myPyDatagram.addString('MOVED') myPyDatagram.addString(charid) myPyDatagram.addUint8(x) myPyDatagram.addUint8(y) myPyDatagram.addUint8(z) self.cWriter.send(myPyDatagram, player)
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 sendStartGame(self, players): datagram = PyDatagram() datagram.addUint8(protocols.ClientMsgId.gameStarted) #nicks = [p.nick for p in players] datagram.addString(players[0].nick) datagram.addString(players[1].nick) self.server.broadcast(datagram)
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 informBan(self, banner, username, time): msg = "%s banned %s for %s hours" self.notify.info(msg) dg = PyDatagram() dg.addString(msg) dgi = PyDatagramIterator(dg) self.cr.handleSystemMessage(dgi)
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 scoreDatagram(self): # Send a test message myPyDatagram = PyDatagram() myPyDatagram.addUint8(END_MESSAGE) myPyDatagram.addInt32(len(self.playerscores)) for pair in self.playerscores: myPyDatagram.addString(pair[0]) myPyDatagram.addInt32(pair[1]) return myPyDatagram
def MOVE_TO(self, charid, dest): (x2, y2, z2) = dest myPyDatagram = PyDatagram() myPyDatagram.addString('MOVE_TO') myPyDatagram.addString(charid) myPyDatagram.addUint8(x2) myPyDatagram.addUint8(y2) myPyDatagram.addUint8(z2) self.cWriter.send(myPyDatagram, self.myConnection)
def GET_PATH(self, charid, dest): (x, y, z) = dest myPyDatagram = PyDatagram() myPyDatagram.addString('GET_PATH') myPyDatagram.addString(charid) myPyDatagram.addUint8(x) myPyDatagram.addUint8(y) myPyDatagram.addUint8(z) self.cWriter.send(myPyDatagram, self.myConnection)
def msgChat(self, msgID, data, senderClient): message = data.getString() self.screenText.appendText("Message: ") self.screenText.appendText(message) self.screenText.appendText("\n") pkg = PyDatagram() pkg.addUint16(SV_MSG_CHAT) pkg.addString(message) for receiverClient in CLIENTS: self.cWriter.send(pkg, receiverClient)
def subscribe(self, avId, access): self.subscribed[avId] = access self.notify.info('Subscribed avatar %s with access %s' % (avId, access)) dgcleanup = self.dclass.aiFormatUpdate("unsubscribe", self.doId, self.air.ourChannel, self.air.ourChannel, [avId]) dg = PyDatagram() dg.addServerHeader(self.GetAccountConnectionChannel(self.avId), self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg)
def sendHand(self, player, hand): datagram = PyDatagram() datagram.addUint8(protocols.ClientMsgId.sendHand) names = [] for card in hand: names.append(card.name) dataStr = self.buildListStr(names) datagram.addString(dataStr) self.server.writer.send(datagram, player.connection)
def handleChatMsg(self, it, player): nick = player.nick message = it.getString() self.server.addToChatLog(nick, message) messenger.send("received_chat_message", sentArgs=[nick, message]) datagram = PyDatagram() datagram.addUint8(ClientMsgId.chatMsg) datagram.addString(nick) datagram.addString(message) self.server.broadcast(datagram)
def sendUpdateBattleground(self, battleground, player): datagram = PyDatagram() datagram.addUint8(protocols.ClientMsgId.sendUpdateBattleground) names = [] for card in battleground: names.append(card.name) dataStr = self.buildListStr(names) datagram.addString(dataStr) datagram.addString(player.nick) self.server.broadcast(datagram)
def connectSuccess(self): """ Successfully connected. But we still can't really do anything until we send an CLIENT_HELLO message. """ self.makeWaitingText() dg = PyDatagram() dg.addUint16(CLIENT_HELLO) dg.addUint32(self.hashVal) dg.addString(self.gameVersion) self.send(dg)
def connect(self, host, port, timeout, nick): self.connection = self.manager.openTCPClientConnection(host, port, timeout) if self.connection: self.reader.addConnection(self.connection) registrationDatagram = PyDatagram() registrationDatagram.addUint8(ServerMsgId.registration) registrationDatagram.addString(nick) self.send(registrationDatagram) logging.info("Connected to server") return True return False
def sendMessage(text, timer): if not mode==MODE_TRAINING: msg = PyDatagram() #send message packet msg.addUint16(PACKET_MSG) msg.addUint16(timer) msg.addString(text) if role==ROLE_SERVER: toAll(msg, activeConnections) setMessage(text, timer) else: cWriter.send(msg, serverConnection)
def _makeAvMsg(self, values, recipient): msg = "%s banned %s for %s hours: %s" % values msgDg = PyDatagram() msgDg.addUint16(6) msgDg.addString(msg) dg = PyDatagram() dg.addServerHeader(recipient, self.air.ourChannel, CLIENTAGENT_SEND_DATAGRAM) dg.addString(msgDg.getMessage()) return dg
def setFields(self, values): dg = PyDatagram() dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_SET_STORED_VALUES) dg.addUint32(self.doId) dg.addUint16(len(values)) items = values.items() for field, value in items: dg.addString(field) for field, value in items: dg.addString(value.getMessage()) self.air.send(dg)
def enterSubmitAcc(self): self.infoLbl = canvas.create_text(287, 210, text="Submitting...", fill="white") if not self.validateEntries(): self.__handleInvalidEntries('accCreate') return dg = PyDatagram() dg.addUint16(ACC_CREATE) dg.addString(self.loginUserName.get()) dg.addString(self.loginPassword.get()) dg.addString(str(getMacAddress())) self.cWriter.send(dg, self.Connection)
def send(self, args=[]): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_LOGIN) print args pkg.addString(args[0]) pkg.addString(args[1]) self.cWriter.send(pkg, self.connection) except: self.log('Bad [' + str(Constants.CMSG_LOGIN) + '] Login Request') print_exc()
def sendMagicWord(self, word, targetId, execute): invokerId = self.air.getAvatarIdFromSender() invoker = self.air.doId2do.get(invokerId) now = time.strftime("%c") 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]) with open("backups/tools/magic-words.altis", "a") as text_file: text_file.write("%s | %s : %s\n" % (now, invokerId, word))
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_DISCONNECT) pkg.addString(args) self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log('Bad [' + str(Constants.CMSG_DISCONNECT) + '] Int Request') print_exc()
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 getFields(self, fields): 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 send(self, message = None): try: print "username: "******"; password: "******", "+ list(message)[1] + '] Login Request') print_exc()
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_HEALTH) pkg.addString(args[0]) #targeted player pkg.addInt32(args[1]) #damage amount self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_INT) + '] Int Request') except: self.log('Bad [' + str(Constants.RAND_INT) + '] Int Request') print_exc()
def MOVED_PASSIVE(self, charid, walkables, path, player): myPyDatagram = PyDatagram() myPyDatagram.addString('MOVED_PASSIVE') myPyDatagram.addString(charid) myPyDatagram.addString(json.dumps(walkables)) myPyDatagram.addString(json.dumps(path)) self.cWriter.send(myPyDatagram, player)
def send(self, username = None, password = None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_AUTH) pkg.addString(username) pkg.addString(password) 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 systemMessage(self, message, channel=10): msgDg = PyDatagram() msgDg.addUint16(6) msgDg.addString(message) self.writeServerEvent('system-message', sourceChannel=self.ourChannel, message=message, targetChannel=channel) dg = PyDatagram() dg.addServerHeader(channel, self.ourChannel, CLIENTAGENT_SEND_DATAGRAM) dg.addString(msgDg.getMessage()) self.send(dg)
def send(self, args = None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_CHAT) pkg.addString(args['userName'])#username pkg.addString(args['message'])#message self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_INT) + '] Int Request') except: self.log('Bad [' + str(Constants.CMSG_CHAT) + '] Chat Request') print_exc()
def send(self, args): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_ENTER_GAME_NAME) pkg.addString(args) #room name self.cWriter.send(pkg, self.connection) print "RequestEnterGameLobby sent" except: self.log('Bad [' + str(Constants.CMSG_ENTER_GAME_NAME) + '] Login Request') print_exc()
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.RAND_STRING) pkg.addString(args['user_id']) pkg.addInt32(args['factionId']) #factionid pkg.addString(args['password']) self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log('Bad [' + str(Constants.RAND_STRING) + '] String Request') print_exc()
def dg_update_player_name(local_id, new_name): """ Tells players that someone has updated their name :param local_id: the local ID of the player changing their name :type local_id: int :param new_name: the new name of the player :type new_name: string :return: the datagram to send :rtype: pydatagram """ dg = PyDatagram() dg.addUint8(UPDATE_NAME) dg.addUint8(local_id) dg.addString(new_name) return dg
def send(self, args=[]): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_CREATE_LOBBY) pkg.addString(args[0]) #game room name pkg.addInt32(int(args[1])) #gamemode pkg.addInt32(int(args[2])) #status self.cWriter.send(pkg, self.connection) except: self.log('Bad [' + str(Constants.CMSG_CREATE_LOBBY) + '] Create Lobby Request')
def prepare(self, message, sentArgs=[], channels=None): dg = PyDatagram() if channels is None: channels = [OtpDoGlobals.MESSENGER_CHANNEL_ALL] dg.addInt8(len(channels)) for channel in channels: dg.addChannel(channel) dg.addChannel(self.msgType) dg.addUint16(self.msgType) dg.addString(message) dg.addString(zlib.compress(cPickle.dumps(sentArgs))) return dg
def send(self, args=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_NPCMOVE) pkg.addString(args[0]) pkg.addUint32(args[1]) #pkg.addUint32(args[2]) self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_INT) + '] Int Request') except: self.log('Bad [' + str(Constants.RAND_INT) + '] Int Request') print_exc()
def send(self, kwargs): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_HEALTH) pkg.addString(kwargs['username']) pkg.addInt32(kwargs['healthChange']) self.cWriter.send(pkg, self.connection) self.log('Sent [' + str(Constants.CMSG_HEALTH) + '] RequestChangeHealth') except: self.log('Bad [' + str(Constants.CMSG_HEALTH) + '] RequestChangeHealth') print_exc()
def performFinalPlayerCheck(self, task): if self.eventMode == ToontownGlobals.EventManagerStrictMode: for toonId in self.toons: toon = self.air.doId2do.get(toonId) if toon: if toon.zoneId != ToontownGlobals.ToontownCentral: dg = PyDatagram() dg.addServerHeader( toon.GetPuppetConnectionChannel(toon.doId), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(158) dg.addString('Client took too long to enter TTC!') self.air.send(dg) return task.done
def send(self, username=None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_REGISTER) userlist = username.split() pkg.addString(userlist[0]) pkg.addString(userlist[1]) self.cWriter.send(pkg, self.connection) #self.log('Sent [' + str(Constants.RAND_STRING) + '] Int Request') except: self.log('Bad [' + str(Constants.CMSG_REGISTER) + '] Int Request') print_exc()
def requestTrueFriendCode(self): avId = self.air.getAvatarIdFromSender() av = self.air.doId2do.get(avId) if not av: return self.air.banManager.ban( avId, "An error occured while processing your request.") datagram = PyDatagram() datagram.addServerHeader(av.GetPuppetConnectionChannel(av.doId), self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(155) datagram.addString("An error occured while processing your request.") self.air.send(datagram)
def handle_client_login(self, connection, di): ## Send the client OUR LOGIN response. (TODO) datagram = PyDatagram() #datagram.addUint16(0) #dummy datagram.addUint32(CLIENT_LOGIN_2_RESP) #msgType datagram.addUint8(0) #returnCode datagram.addString("") #errorString datagram.addString("dev") #username datagram.addUint8(1) #secretChatAllowed datagram.addUint8(1) # Client is always paid. datagram.addInt32(10000) # minutesRemaining, TODO! self.cw.send(datagram, connection)
def kick(reason='No reason specified'): """ Kick the target from the game server. """ target = spellbook.getTarget() if target == spellbook.getInvoker(): return "You can't kick yourself!" datagram = PyDatagram() datagram.addServerHeader( target.GetPuppetConnectionChannel(target.doId), simbase.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(155) datagram.addString('You were kicked by a moderator for the following reason: %s' % reason) simbase.air.send(datagram) return "Kicked %s from the game server!" % target.getName()
def handleClientHello(self, client, dgi): password = dgi.getString() dcHash = dgi.getUint32() updateRate = dgi.getUint8() cmdRate = dgi.getUint8() dg = PyDatagram() dg.addUint16(NetMessages.SV_Hello_Resp) valid = True msg = "" if password != sv_password.getValue(): valid = False msg = "Incorrect password" elif dcHash != self.hashVal: valid = False msg = "DC hash mismatch" dg.addUint8(int(valid)) if not valid: self.notify.warning("Could not verify client %i (%s)" % (client.connection, msg)) # Client did not verify correctly. Let them know and # close them out. dg.addString(msg) self.sendDatagram(dg, client.connection) self.closeClientConnection(client) return # Make sure the client's requested snapshot rate # is within our defined boundaries. updateRate = max(sv_minupdaterate.getValue(), min(updateRate, sv_maxupdaterate.getValue())) client.updateRate = updateRate client.updateInterval = 1.0 / updateRate client.cmdRate = cmdRate client.cmdInterval = 1.0 / cmdRate client.state = ClientState.Verified client.id = self.clientIdAllocator.allocate() self.notify.info("Got hello from client %i, verified, given ID %i" % (client.connection, client.id)) # Tell the client their ID and our tick rate. dg.addUint16(client.id) dg.addUint8(base.ticksPerSec) self.sendDatagram(dg, client.connection) messenger.send('clientConnected', [client])
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) if not os.path.exists('logs/mw'): os.makedirs('logs/mw') 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 sendCommands(self, inputCmds): """Send movement commands to the server""" pkg = PyDatagram() pkg.addUint16(cmdToServer_moveCmds) cmds = inputCmds.cmds t = inputCmds.t # Convert movement list to string for now... # eval on serverside toStr = str(cmds) pkg.addString(self.localId) pkg.addString(toStr) pkg.addUint64(t) # Send the packet self.networkMgr.tcpWriter.send(pkg, self.tcpCon)
def send(self, args=[]): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_CHAT_ALL) pkg.addInt32(args[0]) #sender id pkg.addString(args[1]) #msg self.cWriter.send(pkg, self.connection) # print "id:", self.world.mainCharRef.playerId #elf.log('Sent [' + str(Constants.CMSG_CHAT_ALL) + '] Chat Request') except: self.log('Bad [' + str(Constants.CMSG_CHAT_ALL) + '] Chat Request') print_exc()
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)