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 makeNamedMovementDone(self): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_NAMED_MOVEMENT_DONE) return datagram
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 deleteObject(self): self.notify.warning('deleting object %s' % self.doId) dg = PyDatagram() dg.addServerHeader(DBSERVER_ID, self.air.ourChannel, DBSERVER_DELETE_STORED_OBJECT) dg.addUint32(self.doId) dg.addUint32(0xDEADBEEFL) self.air.send(dg)
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 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 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 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 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 makeTimeDataDatagram(self, frameCount, frameTime, dt): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_TIME_DATA) datagram.addUint32(frameCount) datagram.addFloat32(frameTime) datagram.addFloat32(dt) return datagram
def sendRemoveInterest(self, handle, contextId): datagram = PyDatagram() datagram.addUint16(CONTROL_MESSAGE) datagram.addUint64(sender) datagram.addUint64(self.ourChannel) datagram.addUint16(STATESERVER_BOUNCE_MESSAGE) datagram.addUint16(CLIENT_AGENT_REMOVE_INTEREST) datagram.addUint16(handle) datagram.addUint32(contextId) self.cw.send(datagram, self.connection)
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 sendLoginMsg(self): cr = self.cr datagram = PyDatagram() datagram.addUint16(CLIENT_LOGIN_2) datagram.addString(self.password) datagram.addString(cr.serverVersion) datagram.addUint32(cr.hashVal) self.__addTokenType(datagram) datagram.addString(cr.validateDownload) datagram.addString(cr.wantMagicWords) cr.send(datagram)
def sendLoginMsg(self): cr = self.cr datagram = PyDatagram() datagram.addUint16(CLIENT_LOGIN_3) datagram.addString(self.DISLToken) datagram.addString(cr.serverVersion) datagram.addUint32(cr.hashVal) datagram.addInt32(CLIENT_LOGIN_3_DISL_TOKEN) datagram.addString(cr.validateDownload) datagram.addString(cr.wantMagicWords) cr.send(datagram)
def sendAvatarGenerate(self): datagram = PyDatagram() # Message type is 1 datagram.addUint16(ALL_OBJECT_GENERATE_WITH_REQUIRED) # Avatar class type is 2 datagram.addUint8(2) # A sample id datagram.addUint32(10) # The only required field is the zone field datagram.addUint32(999) self.cw.send(datagram, self.lastConnection)
def makeCamFrustumDatagram(self, focalLength, filmSize, filmOffset): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_CAM_FRUSTUM) datagram.addFloat32(focalLength) datagram.addFloat32(filmSize[0]) datagram.addFloat32(filmSize[1]) datagram.addFloat32(filmOffset[0]) datagram.addFloat32(filmOffset[1]) return datagram
def __sendGetAvatarDetails(self, avId): # return self.ttrFriendsManager.d_getAvatarDetails(avId) return datagram = PyDatagram() avatar = self.__queryAvatarMap[avId].avatar datagram.addUint16(avatar.getRequestID()) datagram.addUint32(avId) self.send(datagram)
def makeCamOffsetDatagram(self, xyz, hpr): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_CAM_OFFSET) datagram.addFloat32(xyz[0]) datagram.addFloat32(xyz[1]) datagram.addFloat32(xyz[2]) datagram.addFloat32(hpr[0]) datagram.addFloat32(hpr[1]) datagram.addFloat32(hpr[2]) return datagram
def removeFriend(self, avatarId): base.localAvatar.sendUpdate('friendsNotify', [base.localAvatar.doId, 1], sendToId=avatarId) datagram = PyDatagram() datagram.addUint16(CLIENT_REMOVE_FRIEND) datagram.addUint32(avatarId) self.send(datagram) self.estateMgr.removeFriend(base.localAvatar.doId, avatarId) for pair in base.localAvatar.friendsList: friendId = pair[0] if friendId == avatarId: base.localAvatar.friendsList.remove(pair) return
def makeCamMovementDatagram(self, xyz, hpr): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_CAM_MOVEMENT) datagram.addFloat32(xyz[0]) datagram.addFloat32(xyz[1]) datagram.addFloat32(xyz[2]) datagram.addFloat32(hpr[0]) datagram.addFloat32(hpr[1]) datagram.addFloat32(hpr[2]) return datagram
def setAllowClientSend(self, avId, dObj, fieldNameList=[]): dg = PyDatagram() dg.addServerHeader(dObj.GetPuppetConnectionChannel(avId), self.ourChannel, CLIENTAGENT_SET_FIELDS_SENDABLE) fieldIds = [] for fieldName in fieldNameList: field = dObj.dclass.getFieldByName(fieldName) if field: fieldIds.append(field.getNumber()) dg.addUint32(dObj.getDoId()) dg.addUint16(len(fieldIds)) for fieldId in fieldIds: dg.addUint16(fieldId) self.send(dg)
def send(self, args = None): try: pkg = PyDatagram() pkg.addUint16(Constants.CMSG_NPCDEATH) pkg.addUint32(args[0]) 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 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 sendAvatarInfoRequests(self, task = None): print 'Sending request Queue for AV Handles' if not hasattr(self, 'avatarInfoRequests'): return if len(self.avatarInfoRequests) == 0: return datagram = PyDatagram() datagram.addUint16(CLIENT_GET_FRIEND_LIST_EXTENDED) datagram.addUint16(len(self.avatarInfoRequests)) for avId in self.avatarInfoRequests: datagram.addUint32(avId) base.cr.send(datagram)
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 checkNameTyped(self, justCheck = False): self.notify.debug('checkNameTyped') if self._submitTypeANameAsPickAName(): return datagram = PyDatagram() datagram.addUint16(CLIENT_SET_WISHNAME) if justCheck: avId = 0 else: avId = self.avId datagram.addUint32(avId) datagram.addString(self.nameEntry.get()) messenger.send('nameShopPost', [datagram]) self.waitForServer()
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 checkNamePattern(self): self.notify.debug('checkNamePattern') datagram = PyDatagram() datagram.addUint16(CLIENT_SET_NAME_PATTERN) datagram.addUint32(self.avId) datagram.addInt16(self.nameIndices[0]) datagram.addInt16(self.nameFlags[0]) datagram.addInt16(self.nameIndices[1]) datagram.addInt16(self.nameFlags[1]) datagram.addInt16(self.nameIndices[2]) datagram.addInt16(self.nameFlags[2]) datagram.addInt16(self.nameIndices[3]) datagram.addInt16(self.nameFlags[3]) messenger.send('nameShopPost', [datagram]) self.waitForServer()
def __handleCongrats(self, avatarChoice): self.acceptedBanner.destroy() self.acceptedText.destroy() self.okButton.destroy() self.acceptedScreen.removeNode() del self.acceptedScreen del self.okButton del self.acceptedText del self.acceptedBanner datagram = PyDatagram() datagram.addUint16(CLIENT_SET_WISHNAME_CLEAR) datagram.addUint32(avatarChoice.id) datagram.addUint8(1) self.send(datagram) self.loginFSM.request('waitForSetAvatarResponse', [avatarChoice])
def __handleReject(self, avList, index): self.rejectDialog.cleanup() datagram = PyDatagram() datagram.addUint16(CLIENT_SET_WISHNAME_CLEAR) avid = 0 for k in avList: if k.position == index: avid = k.id if avid == 0: self.notify.error('Avatar rejected not found in avList. Index is: ' + str(index)) datagram.addUint32(avid) datagram.addUint8(0) self.send(datagram) self.loginFSM.request('waitForAvatarList')
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 requestSecret(self, requesterId): """ Requests a "secret" from the database server. This is a unique string that will be associated with the indicated requesterId, for the purposes of authenticating true-life friends. When the secret is ready, a "requestSecretReply" message will be thrown with three parameters: the result code (0 or 1, indicating failure or success), the generated secret, and the requesterId again. """ datagram = PyDatagram() datagram.addServerHeader(DBSERVER_ID,self.ourChannel,DBSERVER_REQUEST_SECRET) # Indicate the number we want to associate with the new secret. datagram.addUint32(requesterId) # Send it off! self.send(datagram)
def makeFriends(self, avatarAId, avatarBId, flags, context): """ Requests to make a friendship between avatarA and avatarB with the indicated flags (or upgrade an existing friendship with the indicated flags). The context is any arbitrary 32-bit integer. When the friendship is made, or the operation fails, the "makeFriendsReply" event is generated, with two parameters: an integer result code, and the supplied context. """ datagram = PyDatagram() datagram.addServerHeader(DBSERVER_ID, self.ourChannel, DBSERVER_MAKE_FRIENDS) # Indicate the two avatars who are making friends datagram.addUint32(avatarAId) datagram.addUint32(avatarBId) datagram.addUint8(flags) datagram.addUint32(context) self.send(datagram)
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 submitSecret(self, requesterId, secret): """ Submits a "secret" back to the database server for validation. This attempts to match the indicated string, entered by the user, to a string returned by a previous call to requestSecret(). When the response comes back from the server, a "submitSecretReply" message will be thrown with four parameters: the result code (0 or 1, indicating failure or success), the secret again, the requesterId again, and the number associated with the original secret (that is, the original requesterId). """ datagram = PyDatagram() datagram.addServerHeader( DBSERVER_ID, self.ourChannel, DBSERVER_SUBMIT_SECRET) # Pass in our identifying number, and the string. datagram.addUint32(requesterId) datagram.addString(secret) self.send(datagram)
def makeNamedObjectMovementDatagram(self, xyz, hpr, scale, color, hidden, name): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_NAMED_OBJECT_MOVEMENT) datagram.addString(name) datagram.addFloat32(xyz[0]) datagram.addFloat32(xyz[1]) datagram.addFloat32(xyz[2]) datagram.addFloat32(hpr[0]) datagram.addFloat32(hpr[1]) datagram.addFloat32(hpr[2]) datagram.addFloat32(scale[0]) datagram.addFloat32(scale[1]) datagram.addFloat32(scale[2]) datagram.addFloat32(color[0]) datagram.addFloat32(color[1]) datagram.addFloat32(color[2]) datagram.addFloat32(color[3]) datagram.addBool(hidden) return datagram
def handleConnected(self): OTPInternalRepository.handleConnected(self) # register the AI on the state server... dg = PyDatagram() dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_ADD_SHARD) dg.addString(self.districtName) dg.addUint32(self.districtPopulation) self.send(dg) # add a post remove to remove the shard from the state server # when we disconnect from the message director... dg = PyDatagram() dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_REMOVE_SHARD) self.addPostRemove(dg) # create the AI globals... self.createGlobals() self.createZones()
def setAvatar(self, fields, avId, sender): accId = self.GetAccountConnectionChannel(sender) # Give a POST_REMOVE to unload the avatar just # in case we lose connection while working. dgc = PyDatagram() dgc.addServerHeader(avId, accId, STATESERVER_OBJECT_DELETE_RAM) dgc.addUint32(avId) dg = PyDatagram() dg.addServerHeader(accId, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgc.getMessage()) self.air.send(dg) # Activate the avatar on the db stateserver. self.air.sendActivate(avId, 0, 0, self.air.dclassesByName['DistributedToonUD']) # Add the connection to the avatar channel. dg = PyDatagram() dg.addServerHeader(accId, self.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.GetPuppetConnectionChannel(avId)) self.air.send(dg) # Set the sender channel to represent their account affiliation. dg = PyDatagram() dg.addServerHeader(accId, self.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(sender << 32 | avId) self.air.send(dg) # Grant the client ownership of the avatar. dg = PyDatagram() dg.addServerHeader(avId, self.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addChannel(sender << 32 | avId) self.air.send(dg) # Tell the friends manager a toon has gone online. self.__handleToonOnline(avId)
def sendSetLocation(self, doId, parentId, zoneId): dg = PyDatagram() dg.addUint16(CLIENT_OBJECT_LOCATION) dg.addUint32(doId) dg.addUint32(parentId) dg.addUint32(zoneId) self.send(dg)
def sendUpdateToChannel(self, distObj, channelId, fieldName, args): """ Sends a targeted update of a single field to a particular client. The top 32 bits of channelId is ignored; the lower 32 bits should be the client Id of the recipient (i.e. the client's doIdbase). The field update will be sent to the indicated client only. The field must be marked clsend or p2p, and may not be marked broadcast. """ datagram = distObj.dclass.clientFormatUpdate(fieldName, distObj.doId, args) dgi = PyDatagramIterator(datagram) # Reformat the packed datagram to change the message type and # add the target id. dgi.getUint16() dg = PyDatagram() dg.addUint16(CLIENT_OBJECT_UPDATE_FIELD_TARGETED_CMU) dg.addUint32(channelId & 0xffffffff) dg.appendData(dgi.getRemainingBytes()) self.send(dg)
def sendLoginMsg(self): """ Send a message to the server with our loginName """ cr = self.cr # Time to send a login message datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_LOGIN_2) # Add the token--this has been stored as the password. datagram.addString(self.password) # Add the Server Version ID datagram.addString(cr.serverVersion) # Add the dc file hash datagram.addUint32(cr.hashVal) self.__addTokenType(datagram) # Add the download verification string. datagram.addString(cr.validateDownload) # And the magic word enable string. datagram.addString(cr.wantMagicWords) # Send the message cr.send(datagram)
def createObject(self, databaseId, dclass, fields={}, callback=None): """ Create an object in the specified database. databaseId specifies the control channel of the target database. dclass specifies the class of the object to be created. fields is a dict with any fields that should be stored in the object on creation. callback will be called with callback(doId) if specified. On failure, doId is 0. """ # Save the callback: ctx = self.air.getContext() self._callbacks[ctx] = callback # Pack up/count valid fields. fieldPacker = DCPacker() fieldCount = 0 for k, v in fields.items(): field = dclass.getFieldByName(k) if not field: self.notify.error('Creation request for %s object contains ' 'invalid field named %s' % (dclass.getName(), k)) fieldPacker.rawPackUint16(field.getNumber()) fieldPacker.beginPack(field) field.packArgs(fieldPacker, v) fieldPacker.endPack() fieldCount += 1 # Now generate and send the datagram: dg = PyDatagram() dg.addServerHeader(databaseId, self.air.ourChannel, DBSERVER_CREATE_OBJECT) dg.addUint32(ctx) dg.addUint16(dclass.getNumber()) dg.addUint16(fieldCount) dg.appendData(fieldPacker.getString()) self.air.send(dg)
def handle_client_login(self, dgi, connection): # TODO - dynamically set user info from the DBServer token = dgi.getString() self.logger.debug("logging in user %s" % token) # TODO - sanity checks serverVersion = dgi.getString() hashVal = dgi.getInt32() dg = PyDatagram() dg.addUint16(msg_types.CLIENT_LOGIN_2_RESP) dg.addUint8(0) # returnCode dg.addString("") # errorString # begin account details dg.addString(token) # username dg.addUint8(0) # secretChatAllowed dg.addUint32(int(time.time())) # sec dg.addUint32(int(time.clock())) # usec dg.addUint8(1) # isPaid self.cWriter.send(dg, connection)
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 updateClientInterestZones(self, client): origZoneIds = client.currentInterestZoneIds newZoneIds = client.explicitInterestZoneIds | set( client.objectsByZoneId.keys()) if origZoneIds == newZoneIds: # No change. return client.currentInterestZoneIds = newZoneIds addedZoneIds = newZoneIds - origZoneIds removedZoneIds = origZoneIds - newZoneIds dg = PyDatagram() dg.addUint16(NetMessages.SV_GenerateObject) for zoneId in addedZoneIds: self.zonesToClients.setdefault(zoneId, set()).add(client) # The client is opening interest in this zone. Need to inform # client of all objects in this zone. for object in self.objectsByZoneId.get(zoneId, []): if object.owner != client: # Don't do this if the client owns the object, it should # already be generated for them. self.packObjectGenerate(dg, object) self.sendDatagram(dg, client.connection) dg = PyDatagram() dg.addUint16(NetMessages.SV_DeleteObject) for zoneId in removedZoneIds: self.zonesToClients[zoneId].remove(client) # The client is abandoning interest in this zone. Any # objects in this zone should be deleted on the client. for object in self.objectsByZoneId.get(zoneId, []): if object.owner != client: # Never delete objects owned by this client on interest change. dg.addUint32(object.doId) self.sendDatagram(dg, client.connection)
def handle_get_avatars(self, connection, di): ## Send the client OUR AVATARS (TODO) datagram = PyDatagram() #datagram.addUint16(0) #dummy datagram.addUint16(CLIENT_GET_AVATARS_RESP) #msgType datagram.addUint8(0) #ReturnCode (uint8) datagram.addUint16(1) #How many toons does this user have? (uint16) ## lets give our client a avatar. datagram.addUint32(1) #avNum (uint32) datagram.addString('Toon') #avNames 1 (string) datagram.addString('') #avNames 2 (string) datagram.addString('') #avNames 3 (string) datagram.addString('') #avNames 4 (string) datagram.addString( "t\x00\x02\x02\x01\x00\x00\x00\x00\x00\x01\22\x00\22\22" ) #avDNA (hex) datagram.addUint8(1) #avPosition (uint8) datagram.addUint8(1) #avName pos (uint8) self.cw.send(datagram, connection)
def sendLoginMsg(self): """ Send a message to the server with our loginName """ cr = self.cr # Time to send a login message datagram = PyDatagram() # Add message type datagram.addUint16(CLIENT_LOGIN_3) # Add the token datagram.addString(self.DISLToken) # Add the Server Version ID datagram.addString(cr.serverVersion) # Add the dc file hash datagram.addUint32(cr.hashVal) # Token type datagram.addInt32(CLIENT_LOGIN_3_DISL_TOKEN) # Add the download verification string. datagram.addString(cr.validateDownload) # And the magic word enable string. datagram.addString(cr.wantMagicWords) # Send the message cr.send(datagram)
def handle_set_avatar(self, connection, di): ## Send the client HIS character's info. ## TODO: NOT SEND STATIC INFO datagram = PyDatagram() #datagram.addUint16(0) #dummy datagram.addUint32(CLIENT_GET_AVATAR_DETAILS_RESP) #msgType datagram.addUint32(1) #avatarId (uint32) datagram.addUint8(0) #returnCode (uint8) ## NOW, HERE COMES THE GOOD PART datagram.addString( "t\x00\x02\x02\x01\x00\x00\x00\x00\x00\x01\22\x00\22\22" ) #setDNAString datagram.addInt16(1000) #setMaxBankMoney datagram.addInt16(0) #setMoney datagram.addInt16(40) #setMaxMoney datagram.addInt16(15) #setMaxHP datagram.addInt16(15) #setHP self.cw.send(datagram, connection)
def game_start(self): base.oobe() self.display_text.setText("Begin") pkg = PyDatagram() pkg.addUint16(GAME_INITIALIZE) pkg.addUint32(self.network.playerCount) for client_id in self.network.CLIENTS_ID: x = random.randint(1, 5) y = random.randint(1, 5) self.gameEngine.players.append(Player(x, y, 20, client_id)) self.gameEngine.world.attachCharacter( self.gameEngine.players[client_id].playerNP.node()) pkg.addUint32(client_id) pkg.addFloat32(x) pkg.addFloat32(y) for client_id in self.network.CLIENTS_ID: temp = pkg.__copy__() temp.addUint32(client_id) self.network.cWriter.send(temp, self.network.RELATION_OBJ_ID[client_id]) # taskMgr.add(self.update, 'update') self.clientsAlive = self.network.CLIENTS_ID.copy() self.display_text.destroy()
def sendLoginMsg(self): """ Send a message to the game server with our playToken. """ 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 # Time to send a login message datagram = PyDatagram() # Add message type if self.useTTSpecificLogin: datagram.addUint16(CLIENT_LOGIN_TOONTOWN) self.__addPlayToken(datagram) # Add the Server Version ID datagram.addString(cr.serverVersion) # Add the dc file hash datagram.addUint32(cr.hashVal) self.__addTokenType(datagram) # Add the download verification string. # new version doesn't have this field # datagram.addString(cr.validateDownload) # And the magic word enable string. datagram.addString(cr.wantMagicWords) else: datagram.addUint16(CLIENT_LOGIN_2) self.__addPlayToken(datagram) # Add the Server Version ID datagram.addString(cr.serverVersion) # Add the dc file hash datagram.addUint32(cr.hashVal) self.__addTokenType(datagram) # Add the download verification string. datagram.addString(cr.validateDownload) # And the magic word enable string. datagram.addString(cr.wantMagicWords) # Send the message cr.send(datagram)
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 handleClientCreateObject(self, datagram, dgi): """ client wants to create an object, so we store appropriate data, and then pass message along to corresponding zones """ connection = datagram.getConnection() zoneId = dgi.getUint32() classId = dgi.getUint16() doId = dgi.getUint32() client = self.clientsByConnection[connection] if self.getDoIdBase(doId) != client.doIdBase: self.notify.warning( "Ignoring attempt to create invalid doId %s from client %s" % (doId, client.doIdBase)) return dclass = self.dclassesByNumber[classId] object = client.objectsByDoId.get(doId) if object: # This doId is already in use; thus, this message is # really just an update. if object.dclass != dclass: self.notify.warning( "Ignoring attempt to change object %s from %s to %s by client %s" % (doId, object.dclass.getName(), dclass.getName(), client.doIdBase)) return self.setObjectZone(client, object, zoneId) else: if self.notify.getDebug(): self.notify.debug( "Creating object %s of type %s by client %s" % (doId, dclass.getName(), client.doIdBase)) object = self.Object(doId, zoneId, dclass) client.objectsByDoId[doId] = object client.objectsByZoneId.setdefault(zoneId, set()).add(object) self.objectsByZoneId.setdefault(zoneId, set()).add(object) self.updateClientInterestZones(client) # Rebuild the new datagram that we'll send on. We shim in the # doIdBase of the owner. dg = PyDatagram() dg.addUint16(OBJECT_GENERATE_CMU) dg.addUint32(client.doIdBase) dg.addUint32(zoneId) dg.addUint16(classId) dg.addUint32(doId) dg.appendData(dgi.getRemainingBytes()) self.sendToZoneExcept(zoneId, dg, [client])
def sendLoginMsg(self): DISLID = config.GetInt('fake-DISL-PlayerAccountId', 0) if not DISLID: NameStringId = 'DISLID_%s' % self.loginName DISLID = config.GetInt(NameStringId, 0) cr = self.cr datagram = PyDatagram() datagram.addUint16(CLIENT_LOGIN) datagram.addString(self.loginName) if cr.connectMethod != cr.CM_HTTP: datagram.addUint32(cr.tcpConn.getAddress().getIp()) else: datagram.addUint32(0) datagram.addUint16(5150) datagram.addString(cr.serverVersion) datagram.addUint32(cr.hashVal) datagram.addString(self.password) datagram.addBool(self.createFlag) datagram.addString(cr.validateDownload) datagram.addString(cr.wantMagicWords) datagram.addUint32(DISLID) datagram.addString(config.GetString('otp-whitelist', 'YES')) cr.send(datagram)
def handleClientLoginToontown(self, di, conn): if(MAINTENANCE == True): dg = PyDatagram() dg.addUint16(CLIENT_GO_GET_LOST) dg.addUint16(151) dg.addString('The servers are currently closed for maintenance.') self.cw.send(dg, conn) else: token = di.getString() sv = di.getString() if (token != 'daXy321/4432125/DSaGSX=='): self.notify.warning('Client doesn\'t have temporary token, booting.') dg = PyDatagram() dg.addUint16(CLIENT_GO_GET_LOST) dg.addUint16(101) dg.addString('Login token: %s doesn\'t exist.' % token) self.cw.send(dg, conn) elif (sv != SERVER_VERSION): self.notify.warning('Booting client out.') dg = PyDatagram() dg.addUint16(CLIENT_GO_GET_LOST) dg.addUint16(124) dg.addString('Client and Server version do not match. Server is running ' + SERVER_VERSION + ', while client was running ' + sv + '.') self.cw.send(dg, conn) else: now = datetime.now dg = PyDatagram() dg.addUint16(CLIENT_LOGIN_TOONTOWN_RESP) dg.addUint8(0) #Return Code dg.addString('OK') #respString dg.addUint32(123456) #Account Number dg.addString('Infinity') #Account Name dg.addUint8(1) #accountNameApproved dg.addString('YES') #self.openChatEnabled dg.addString('YES') #self.createFriendsWithChat dg.addString('YES') #chatCodeCreationRule dg.addUint32(time.time()) #sec? dg.addUint32(time.clock()) #usec? dg.addString('FULL') #self.isPaid dg.addString('YES') #WhiteListReponse dg.addString(time.strftime('%Y-%m-%d'))#lastLoggedInStr dg.addInt32(0) #accountDays dg.addString('NO_PARENT_ACCOUNT') dg.addString('Infinity') self.cw.send(dg, conn)
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 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 sendLoginMsg(self): cr = self.cr tokenString = '' access = base.config.GetString('force-paid-status', '') if access == '': access = 'FULL' elif access == 'paid': access = 'FULL' elif access == 'unpaid': access = 'VELVET_ROPE' elif access == 'VELVET': access = 'VELVET_ROPE' else: self.notify.error( "don't know what to do with force-paid-status %s" % access) tokenString += 'TOONTOWN_ACCESS=%s&' % access tokenString += 'TOONTOWN_GAME_KEY=%s&' % self.loginName wlChatEnabled = 'YES' if base.config.GetString('otp-whitelist', 'YES') == 'NO': wlChatEnabled = 'NO' tokenString += 'WL_CHAT_ENABLED=%s &' % wlChatEnabled openChatEnabled = 'NO' if cr.openChatAllowed: openChatEnabled = 'YES' tokenString += 'OPEN_CHAT_ENABLED=%s&' % openChatEnabled createFriendsWithChat = 'NO' if cr.allowSecretChat: createFriendsWithChat = 'CODE' tokenString += 'CREATE_FRIENDS_WITH_CHAT=%s&' % createFriendsWithChat chatCodeCreationRule = 'No' if cr.allowSecretChat: if base.config.GetBool('secret-chat-needs-parent-password', 0): chatCodeCreationRule = 'PARENT' else: chatCodeCreationRule = 'YES' tokenString += 'CHAT_CODE_CREATION_RULE=%s&' % chatCodeCreationRule DISLID = config.GetInt('fake-DISL-PlayerAccountId', 0) if not DISLID: NameStringId = 'DISLID_%s' % self.loginName DISLID = config.GetInt(NameStringId, 0) tokenString += 'ACCOUNT_NUMBER=%d&' % DISLID tokenString += 'ACCOUNT_NAME=%s&' % self.loginName tokenString += 'GAME_USERNAME=%s&' % self.loginName tokenString += 'ACCOUNT_NAME_APPROVED=TRUE&' tokenString += 'FAMILY_NUMBER=&' tokenString += 'Deployment=US&' withParentAccount = base.config.GetBool('dev-with-parent-account', 0) if withParentAccount: tokenString += 'TOON_ACCOUNT_TYPE=WITH_PARENT_ACCOUNT&' else: tokenString += 'TOON_ACCOUNT_TYPE=NO_PARENT_ACCOUNT&' tokenString += 'valid=true' self.notify.info('tokenString=\n%s' % tokenString) datagram = PyDatagram() datagram.addUint16(CLIENT_LOGIN_TOONTOWN) playToken = tokenString datagram.addString(playToken) datagram.addString('dev') datagram.addUint32(cr.hashVal) datagram.addUint32(4) magicWords = base.config.GetString('want-magic-words', '') datagram.addString(magicWords) cr.send(datagram)
def makeSwapReadyDatagram(self): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_SWAP_READY) return datagram
def makeExitDatagram(self): datagram = PyDatagram() datagram.addUint32(self.packetNumber) self.packetNumber = self.packetNumber + 1 datagram.addUint8(CLUSTER_EXIT) return datagram