def handleConnected(self): self.notify.info('Yarn. Waking up (This may take a while!).') ToontownInternalRepository.handleConnected(self) self.districtId = self.allocateChannel() self.distributedDistrict = ToontownDistrictAI(self) self.distributedDistrict.setName(self.districtName) self.distributedDistrict.generateWithRequiredAndId( self.districtId, self.getGameDoId(), 2) # Claim ownership of that district... dg = PyDatagram() dg.addServerHeader( self.districtId, self.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(self.ourChannel) self.send(dg) self.notify.info('Creating Global Managers') self.createGlobals() self.notify.info('Creating Toontown') self.createZones() self.statusSender.start() self.distributedDistrict.b_setAvailable(1) self.notify.info('District is now ready.')
def enterControlled(self, avId, accId): self.driverId = avId fieldList = ['setComponentL', 'setComponentX', 'setComponentY', 'setComponentZ', 'setComponentH', 'setComponentP', 'setComponentR', 'setComponentT', 'setSmStop', 'setSmH', 'setSmZ', 'setSmXY', 'setSmXZ', 'setSmPos', 'setSmHpr', 'setSmXYH', 'setSmXYZH', 'setSmPosHpr', 'setSmPosHprL', 'clearSmoothing', 'suggestResync', 'returnResync'] #self.air.setAllowClientSend(avId, self, fieldList, accId) #hack until CLIENTAGENT_SET_FIELDS_SENDABLE works #probably should not be kept for any longer than it needs to dg = PyDatagram() dg.addServerHeader(self.doId, self.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addUint64(accId << 32 | avId) self.air.send(dg) self.d_setState('C', self.driverId)
def onCrossClicked(self): if self.phase == 'tile' and self.cux is not False and self.party['yourturn']: if self.subphase == 'free': # if we clicked on a character if self.party['map']['tiles'][self.cux][self.cuy][self.cuz].has_key('char'): charid = self.party['map']['tiles'][self.cux][self.cuy][self.cuz]['char'] myPyDatagram = PyDatagram() myPyDatagram.addUint8(GET_PASSIVE_WALKABLES) myPyDatagram.addString(charid) self.cWriter.send(myPyDatagram, self.myConnection) elif self.subphase == 'passivewalkables': self.clearZone() self.cancel_snd.play() self.subphase = 'free' elif self.subphase == 'move': self.clearZone() self.cancel_snd.play() self.subphase = None self.turn() elif self.subphase == 'attack': self.clearZone() self.cancel_snd.play() self.subphase = None self.turn()
def updateAllPartyLists(self): parties = deepcopy(self.parties) for party in parties.values(): del party['map']['tiles'] for player in self.playersinlobby: myPyDatagram = PyDatagram() myPyDatagram.addUint8(UPDATE_PARTY_LIST) myPyDatagram.addString32(json.dumps(parties)) self.cWriter.send(myPyDatagram, player)
def __ready(self): dg = PyDatagram() dg.addServerHeader(self.districtStats.doId, self.ourChannel, STATESERVER_OBJECT_DELETE_RAM) dg.addUint32(self.districtStats.doId) self.addPostRemove(dg) self.apiMgr = self.generateGlobalObject(100001, "ShardAPIManager") self.apiMgr.start() self.apiMgr.d_setShardData() self.banMgr = self.generateGlobalObject(100002, "BanManager")
def login(self, cookie): target = self.air.getMsgSender() datagram = PyDatagram() datagram.addServerHeader( target, self.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) self.air.send(datagram) self.sendUpdateToChannel(target, 'acceptLogin', [])
def enterSetAvatarTask(self, channel, task): # Finally, grant ownership and shut down. datagram = PyDatagram() datagram.addServerHeader( self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off') return task.done
def handleConnected(self): self.districtId = self.allocateChannel() self.distributedDistrict = ToontownDistrictAI(self) self.distributedDistrict.setName(self.districtName) self.distributedDistrict.generateWithRequiredAndId(simbase.air.districtId, self.getGameDoId(), 2) dg = PyDatagram() dg.addServerHeader(simbase.air.districtId, simbase.air.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(simbase.air.ourChannel) simbase.air.send(dg) self.createGlobals() self.createZones()
def killConnection(self, connId, reason): datagram = PyDatagram() datagram.addServerHeader(connId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(122) datagram.addString(reason) self.air.send(datagram)
def bootClient(self, reason, av): dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(av), self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(106) dg.addString(reason) self.air.send(dg)
def sendShardInfo(self): dg = PyDatagram() dg.addServerHeader(self.serverId, self.ourChannel, STATESERVER_UPDATE_SHARD) dg.addString(self.districtName) dg.addUint32(self.districtPopulation) self.send(dg)
def moveCharacterTo(self, charid, dest): (x2, y2, z2) = dest myPyDatagram = PyDatagram() myPyDatagram.addUint8(MOVE_TO) myPyDatagram.addString(charid) myPyDatagram.addUint8(x2) myPyDatagram.addUint8(y2) myPyDatagram.addUint8(z2) self.cWriter.send(myPyDatagram, self.myConnection)
def doUpdate(self, updateType, data): self.heartbeat() if updateType == "inv": return # rip crash dg = PyDatagram() dg.addUint8(0) dg.addString(updateType) dg.appendData(data) self.setShardData(dg.getMessage())
def killConnection(self, connectionId, reason): # Sends CLIENTAGENT_EJECT to the given connectionId with the given reason. datagram = PyDatagram() datagram.addServerHeader(connectionId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(OTPGlobals.BootedReason["connectionKilled"]) datagram.addString(reason) self.air.send(datagram)
def toonOnline(self, doId, friendsList): self.onlineToons.append(doId) channel = self.GetPuppetConnectionChannel(doId) dgcleanup = self.dclass.aiFormatUpdate('goingOffline', self.doId, self.doId, self.air.ourChannel, [doId]) dg = PyDatagram() dg.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg) for friend in friendsList: friendId = friend[0] if friend[0] in self.onlineToons: self.sendUpdateToAvatarId(doId, 'friendOnline', [friendId, 0, 0]) self.sendUpdateToAvatarId(friendId, 'friendOnline', [doId, 0, 0])
def killConnection(self, connId, code=122, reason=''): self.notify.info('Booting client: %d out for reason(%d): %s' % (int(connId), int(code), str(reason))) dg = PyDatagram() dg.addServerHeader(connId, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(int(code)) dg.addString(str(reason)) self.air.send(dg)
def path(self, charid, dest): orig = self.getCharacterCoords(charid) origdir = self.sprites[charid].realdir (x, y, z) = dest myPyDatagram = PyDatagram() myPyDatagram.addUint8(GET_PATH) myPyDatagram.addString(charid) myPyDatagram.addUint8(x) myPyDatagram.addUint8(y) myPyDatagram.addUint8(z) self.cWriter.send(myPyDatagram, self.myConnection)
def enterSetAvatarTask(self, channel, task): # Finally, grant ownership and shut down. datagram = PyDatagram() datagram.addServerHeader( self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEventMessage('avatarChosen', self.avId, self.target) self.demand('Off') return task.done
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 enterJudgeName(self): dg = PyDatagram(self.name) dgi = PyDatagramIterator(dg) isPattern, name = isNamePattern(dgi, self.csm.namePattern, self.dna.gender) if not name: self.demand('Kill', 'There\'s an issue with your name request!') return toonFields = {'WishNameState': ('PENDING',), 'WishName': (name,)} if isPattern: toonFields['WishNameState'] = ('',) toonFields['WishName'] = ('',) toonFields['setName'] = (name,) if self.avId: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.avId, self.csm.air.dclassesByName['DistributedToonUD'], toonFields) self.csm.air.writeServerEvent('avatarWishname', self.avId, name) self.csm.accountDB.handlePostNameRequest(self.avId, name) self.csm.sendUpdateToAccountId(self.target, 'updateNameResp', []) self.demand('Off')
def __offlineToonOnline(self, avId, activated, otherId=None, accId=None): if not (otherId and activated and accId): return # Undeclare to the friend! dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(avId), self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT) dg.addUint32(otherId) self.air.send(dg) # Undeclare to our now-offline avId (they may still be around, about to log into a new toon!) dg = PyDatagram() dg.addServerHeader(self.GetAccountConnectionChannel(accId), self.air.ourChannel, CLIENTAGENT_UNDECLARE_OBJECT) dg.addUint32(avId) self.air.send(dg) # Tell them they're offline! self.sendUpdateToAvatarId(avId, 'friendOffline', [otherId])
def killConnection(self, connectionId, reason, code=OTPGlobals.BootedConnectionKilled): datagram = PyDatagram() datagram.addServerHeader(connectionId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(code) datagram.addString(reason) self.air.send(datagram)
def authenticate(self): login = self.loginwindow.loginEntry.get() password = self.loginwindow.passwordEntry.get() self.cManager = QueuedConnectionManager() self.cListener = QueuedConnectionListener(self.cManager, 0) self.cReader = QueuedConnectionReader(self.cManager, 0) self.cWriter = ConnectionWriter(self.cManager, 0) self.cReader.setTcpHeaderSize(4) self.cWriter.setTcpHeaderSize(4) self.myConnection = self.cManager.openTCPClientConnection(IP, PORT, 5000) if self.myConnection: self.cReader.addConnection(self.myConnection) print 'Client listening on', IP, ':', PORT taskMgr.add(self.tskReaderPolling, "Poll the connection reader") myPyDatagram = PyDatagram() myPyDatagram.addUint8(LOGIN_MESSAGE) myPyDatagram.addString(login) myPyDatagram.addString(password) self.cWriter.send(myPyDatagram, self.myConnection) else: print 'Can\'t connect to server on', IP, ':', PORT
def login(self, cookie, sig): self.notify.debug("Received login cookie %r from %d" % (cookie, self.air.getMsgSender())) sender = self.air.getMsgSender() if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString("Logins are currently disabled. Please try again later.") self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, "Client is already logged in.") return # Test the signature key = ( config.GetString("csmud-secret", "streetlamps") + config.GetString("server-version", "no_version_set") + FIXED_KEY ) computedSig = hmac.new(key, cookie, hashlib.sha256).digest() if sig != computedSig: self.killConnection(sender, "The accounts database rejected your cookie") return if sender in self.connection2fsm: self.killConnectionFSM(sender) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request("Start", cookie)
def attack(self, charid, targetid): myPyDatagram = PyDatagram() myPyDatagram.addUint8(ATTACK) myPyDatagram.addString(charid) myPyDatagram.addString(targetid) self.cWriter.send(myPyDatagram, self.myConnection)
def toonOnline(self, doId, fields): self.onlineToons.append(doId) self.toonAccess[doId] = fields.get("setAdminAccess", [0])[0] self.toonNames[doId] = fields["setName"][0] self.toonAccIds[doId] = fields.get("setDISLid", [0])[0] friendsList = fields["setFriendsList"][0] channel = self.GetPuppetConnectionChannel(doId) dgcleanup = self.dclass.aiFormatUpdate("goingOffline", self.doId, self.doId, self.air.ourChannel, [doId]) dg = PyDatagram() dg.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg) for friend in friendsList: friendId = friend[0] if friend[0] in self.onlineToons: self.sendUpdateToAvatarId(doId, "friendOnline", [friendId, 0, 0]) self.sendUpdateToAvatarId(friendId, "friendOnline", [doId, 0, 0])
def killConnection(self, connId, reason): datagram = PyDatagram() datagram.addServerHeader( connId, self.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(122) datagram.addString(reason) self.air.send(datagram)
def createParty(self, mapname): import time partyname = str(int(time.time())) myPyDatagram = PyDatagram() myPyDatagram.addUint8(CREATE_PARTY) myPyDatagram.addString(partyname) myPyDatagram.addString(mapname) self.cWriter.send(myPyDatagram, self.myConnection)
def enterSetAvatarTask(self, channel, task): # Finally, grant ownership and shut down. datagram = PyDatagram() datagram.addServerHeader( self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) fields = self.avatar fields.update({'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]}) self.csm.air.friendsManager.addToonData(self.avId, fields) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off') return task.done
def setShardData(self, data): dg = PyDatagram(data) di = PyDatagramIterator(dg) context = di.getUint8() while di.getRemainingSize(): self._doUpdateShard(di) if context > 0: self.sendUpdateToChannel(self.air.getMsgSender(), "setShardDataRes", [context])
def doSend(self, targets, origin=None): if origin is None: origin = self.air.ourChannel self.setOrigin(origin) self.setTargets(targets) for target in targets: dg = self.dclass.aiFormatGenerate(self, self.air.allocateChannel(), 0, 0, target, self.air.serverId, []) self.air.send(PyDatagram(dg.getMessage()[17:]))
def handleConnected(self): ToontownInternalRepository.handleConnected(self) self.districtId = self.allocateChannel() self.notify.info('Creating new district (%d)...' % self.districtId) self.distributedDistrict = ToontownDistrictAI(self) self.distributedDistrict.setName(self.districtName) self.distributedDistrict.generateWithRequiredAndId( self.districtId, self.getGameDoId(), 2) # Claim ownership of that district... self.notify.info('Claiming ownership of district (%d)...' % self.districtId) dg = PyDatagram() dg.addServerHeader(self.districtId, self.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(self.ourChannel) self.send(dg) self.notify.info('Creating global objects...') self.createGlobals() self.notify.info('Creating zones (Playgrounds and Cog HQs)...') self.createZones() self.statusSender.start() self.notify.info('Making district available to enter...') self.distributedDistrict.b_setAvailable(1) self.notify.info('District is now ready. Have fun in Toontown!')
def createGlobals(self): self.csm = simbase.air.generateGlobalObject( OTP_DO_ID_CLIENT_SERVICES_MANAGER, 'ClientServicesManager') self.chatAgent = simbase.air.generateGlobalObject( OTP_DO_ID_CHAT_MANAGER, 'ChatAgent') self.friendsManager = simbase.air.generateGlobalObject( OTP_DO_ID_TT_FRIENDS_MANAGER, 'TTFriendsManager') self.globalPartyMgr = simbase.air.generateGlobalObject( OTP_DO_ID_GLOBAL_PARTY_MANAGER, 'GlobalPartyManager') if config.GetBool('want-top-toons', True): if OTP_DO_ID_TOONTOWN_TOP_TOONS_MGR == 100003: self.topToonsMgr = DistributedTopToonsManagerUD(self) self.topToonsMgr.generateWithRequiredAndId( 100003, self.getGameDoId(), 2) dg = PyDatagram() dg.addServerHeader(100003, self.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(self.ourChannel) self.send(dg) else: self.topToonsMgr = self.generateGlobalObject( OTP_DO_ID_TOONTOWN_TOP_TOONS_MGR, 'DistributedTopToonsManager')
def handleConnected(self): ToontownInternalRepository.handleConnected(self) self.districtId = self.allocateChannel() self.notify.info('Creating district (%d)...' % self.districtId) self.district = ToontownDistrictAI(self) self.district.setName(self.districtName) self.district.setDescription(self.districtDescription) self.district.generateWithRequiredAndId(self.districtId, self.getGameDoId(), OTP_ZONE_ID_MANAGEMENT) self.notify.info('Claiming ownership of district (%d)...' % self.districtId) datagram = PyDatagram() datagram.addServerHeader(self.districtId, self.ourChannel, STATESERVER_OBJECT_SET_AI) datagram.addChannel(self.ourChannel) self.send(datagram) self.notify.info('Creating local objects...') self.createLocals() self.notify.info('Creating global objects...') self.createGlobals() self.notify.info('Creating zones (Playgrounds and Cog HQs)...') self.createZones() self.notify.info('Making district available...') self.district.b_setAvailable(1) self.notify.info( 'District is now ready. Have fun in Toontown Offline!')
def handleConnected(self): self.notify.info('Yarn. Waking up (This may take a while!).') ToontownInternalRepository.handleConnected(self) self.districtId = self.allocateChannel() self.distributedDistrict = ToontownDistrictAI(self) self.distributedDistrict.setName(self.districtName) self.distributedDistrict.generateWithRequiredAndId( self.districtId, self.getGameDoId(), 2) # Claim ownership of that district... dg = PyDatagram() dg.addServerHeader(self.districtId, self.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(self.ourChannel) self.send(dg) self.notify.info('Creating Global Managers') self.createGlobals() self.notify.info('Creating Toontown') self.createZones() self.statusSender.start() self.distributedDistrict.b_setAvailable(1) self.notify.info('District is now ready.')
def login(self, cookie, sessionKey): self.notify.debug('Received login cookie %r from %d' % (cookie, self.air.getMsgSender())) sender = self.air.getMsgSender() if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString( 'Logins are currently disabled. Please try again later.') self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, 'Client is already logged in.') return if sender in self.connection2fsm: # Hot fix for potential toons that's FSM is stuck in state. self.connection2fsm[sender].demand('Off') # kick the client because there is a major issue! self.killConnection( sender, 'Failed to login, because your account is already in FSM state!' ) return if sessionKey != self.sessionKey: self.killConnection( sender, 'Failed to login, recieved a bad login cookie!') # notify the admin that someone tried to login with a custom client. self.notify.warning( '%s: Tried to login with a custom client using sessionKey, %s!' % (sender, str(sessionKey))) return if self.banManager.getToonBanned(cookie): self.killConnection(sender, self.banManager.getToonBanReason(cookie)) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request('Start', cookie)
def enterSetAvatarTask(self, channel, task): datagram = PyDatagram() datagram.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target << 32 | self.avId) self.csm.air.send(datagram) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off') return task.done
def createGlobals(self): self.csm = simbase.air.generateGlobalObject(OTP_DO_ID_CLIENT_SERVICES_MANAGER, 'ClientServicesManager') self.chatAgent = simbase.air.generateGlobalObject(OTP_DO_ID_CHAT_MANAGER, 'ChatAgent') self.friendsManager = simbase.air.generateGlobalObject(OTP_DO_ID_TT_FRIENDS_MANAGER, 'TTFriendsManager') self.globalPartyMgr = simbase.air.generateGlobalObject(OTP_DO_ID_GLOBAL_PARTY_MANAGER, 'GlobalPartyManager') if config.GetBool('want-top-toons', True): if OTP_DO_ID_TOONTOWN_TOP_TOONS_MGR == 100003: self.topToonsMgr = DistributedTopToonsManagerUD(self) self.topToonsMgr.generateWithRequiredAndId(100003, self.getGameDoId(), 2) dg = PyDatagram() dg.addServerHeader(100003, self.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(self.ourChannel) self.send(dg) else: self.topToonsMgr = self.generateGlobalObject(OTP_DO_ID_TOONTOWN_TOP_TOONS_MGR, 'DistributedTopToonsManager')
def login(self, cookie): target = self.air.getMsgSender() datagram = PyDatagram() datagram.addServerHeader(target, self.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) self.air.send(datagram) self.sendUpdateToChannel(target, 'acceptLogin', [])
def login(self, cookie, sessionKey): sender = self.air.getMsgSender() #if not self.AccountFirewallUD.checkPlayerLogin(cookie): # self.killConnection(sender, 'Your account has been disallowed login to Project Altis. Please try again later.') # return self.notify.debug('Received login cookie %r from %d' % (cookie, sender)) if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString( 'Logins are currently disabled. Please try again later.') self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, 'Client is already logged in.') return if sender in self.connection2fsm: # hot fix, remove the sender from the fsm and request the fsm state OFF self.connection2fsm[sender].demand('Off') if sessionKey != self.sessionKey: self.killConnection( sender, 'Failed to login, recieved a bad login cookie!') # notify the admin that someone tried to login with a custom client. self.notify.warning('%s: Tried to login with a custom client!' % (sender)) return if self.banManager.getToonBanned(cookie): self.killConnection(sender, self.banManager.getToonBanReason(cookie)) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request('Start', cookie)
def enterSetAvatarTask(self, channel, task): # Finally, grant ownership and shut down. datagram = PyDatagram() datagram.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off') return task.done
def login(self, cookie, sig, secret): self.notify.debug('Received login cookie %r from %d' % (cookie, self.air.getMsgSender())) sender = self.air.getMsgSender() if not self.loginsEnabled: # Logins are currently disabled... RIP! dg = PyDatagram() dg.addServerHeader(sender, self.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(200) dg.addString( 'Logins are currently disabled. Please try again later.') self.air.send(dg) if sender >> 32: # Oops, they have an account ID on their connection already! self.killConnection(sender, 'Client is already logged in.') return # Test Server Secret serversecret = config.GetString('csmud-secret', 'streetlamps') if secret != serversecret: self.killConnection(sender, 'The accounts database rejcts you secret key') return # Test the signature key = config.GetString( 'csmud-secret', 'streetlamps') + config.GetString( 'server-version', 'no_version_set') + FIXED_KEY computedSig = hmac.new(key, cookie, hashlib.sha256).digest() if sig != computedSig: self.killConnection(sender, 'The accounts database rejected your cookie') return if sender in self.connection2fsm: self.killConnectionFSM(sender) return self.connection2fsm[sender] = LoginAccountFSM(self, sender) self.connection2fsm[sender].request('Start', cookie)
def login(self, cookie, authKey): sender = self.air.getMsgSender() hwid = cookie.split("#")[1] backupCookie = cookie.split("#")[0] cookie = cookie.split("#")[0] self.pendingLogins[sender] = (sender, hwid, backupCookie, cookie, authKey) # CLIENTAGENT_GET_NETWORK_ADDRESS is defined in OtpDoGlobals for backwards compatibility with old versions of Panda3D datagram = PyDatagram() datagram.addServerHeader(sender, self.air.ourChannel, OtpDoGlobals.CLIENTAGENT_GET_NETWORK_ADDRESS) datagram.addUint32(sender) self.air.send(datagram)
def __ready(self): dg = PyDatagram() dg.addServerHeader(self.districtStats.doId, self.ourChannel, STATESERVER_OBJECT_DELETE_RAM) dg.addUint32(self.districtStats.doId) self.addPostRemove(dg) self.apiMgr = self.generateGlobalObject(100001, "ShardAPIManager") self.apiMgr.start() self.apiMgr.d_setShardData() self.banMgr = self.generateGlobalObject(100002, "BanManager") self.trophyMgr.updateToonData()
def handleConnected(self): self.districtId = self.allocateChannel() self.distributedDistrict = ToontownDistrictAI(self) self.distributedDistrict.setName(self.districtName) self.distributedDistrict.generateWithRequiredAndId( simbase.air.districtId, self.getGameDoId(), 2) dg = PyDatagram() dg.addServerHeader(simbase.air.districtId, simbase.air.ourChannel, STATESERVER_OBJECT_SET_AI) dg.addChannel(simbase.air.ourChannel) simbase.air.send(dg) self.createGlobals() self.createZones()
def enterControlled(self, avId, accId): self.driverId = avId fieldList = [ 'setComponentL', 'setComponentX', 'setComponentY', 'setComponentZ', 'setComponentH', 'setComponentP', 'setComponentR', 'setComponentT', 'setSmStop', 'setSmH', 'setSmZ', 'setSmXY', 'setSmXZ', 'setSmPos', 'setSmHpr', 'setSmXYH', 'setSmXYZH', 'setSmPosHpr', 'setSmPosHprL', 'clearSmoothing', 'suggestResync', 'returnResync' ] dg = PyDatagram() dg.addServerHeader(self.doId, self.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addUint64(accId << 32 | avId) self.air.send(dg) self.d_setState('C', self.driverId)
def w(klass, data): if data: dg = PyDatagram(data) dgi = PyDatagramIterator(dg) def unpackPlant(_): return dgi.getUint32, dgi.getInt8(), dgi.getUint32( ), dgi.getInt8(), dgi.getUint16() flowers = map(unpackPlant, range(10)) trees = map(unpackPlant, range(8)) st = dgi.getUint8() started = dgi.getBool() else: flowers = NULL_FLOWERS trees = NULL_TREES st = NULL_STATUARY started = 0 return f(klass, started, flowers, trees, st)
def enterSetAvatarTask(self, channel, task): # Finally, grant ownership and shut down. datagram = PyDatagram() datagram.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(self.target << 32 | self.avId) self.csm.air.send(datagram) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) fields = self.avatar fields.update( {'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]}) self.csm.air.friendsManager.addToonData(self.avId, fields) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off') return task.done
def toonOnline(self, doId, fields): self.onlineToons.append(doId) self.toonAccess[doId] = fields.get('setAdminAccess', [0])[0] self.toonNames[doId] = fields['setName'][0] self.toonAccIds[doId] = fields.get('setDISLid', [0])[0] friendsList = fields['setFriendsList'][0] channel = self.GetPuppetConnectionChannel(doId) dgcleanup = self.dclass.aiFormatUpdate('goingOffline', self.doId, self.doId, self.air.ourChannel, [doId]) dg = PyDatagram() dg.addServerHeader(channel, self.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.air.send(dg) for friend in friendsList: friendId = friend[0] if friend[0] in self.onlineToons: self.sendUpdateToAvatarId(doId, 'friendOnline', [friendId, 0, 0]) self.sendUpdateToAvatarId(friendId, 'friendOnline', [doId, 0, 0])
def inviteeFriendResponse(self, response, context): avId = self.air.getAvatarIdFromSender() if not context in self.requests: self.air.writeServerEvent('suspicious', avId=avId, issue='Player tried to respond to a friend request that doesn\'t exist!') return if avId != self.requests[context][0][1]: self.air.writeServerEvent('suspicious', avId=avId, issue='Player tried to respond to someone else\'s request!') return if self.requests[context][1] == 'cancelled': self.air.writeServerEvent('suspicious', avId=avId, issue='Player tried to respond to non-active friend request!') return self.sendUpdateToAvatarId(self.requests[context][0][0], 'friendResponse', [response, context]) if response == 1: requested = self.air.doId2do.get(self.requests[context][0][1]) requester = self.air.doId2do.get(self.requests[context][0][0]) if not (requested and requester): # Likely they logged off just before a response was sent. RIP. return # Allow both toons to teleport to each other. dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(requested.getDoId()), self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT) dg.addUint32(requester.getDoId()) dg.addUint16(self.air.dclassesByName['DistributedToonAI'].getNumber()) self.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.GetPuppetConnectionChannel(requester.getDoId()), self.air.ourChannel, CLIENTAGENT_DECLARE_OBJECT) dg.addUint32(requested.getDoId()) dg.addUint16(self.air.dclassesByName['DistributedToonAI'].getNumber()) self.air.send(dg) requested.extendFriendsList(requester.getDoId(), 0) requester.extendFriendsList(requested.getDoId(), 0) requested.d_setFriendsList(requested.getFriendsList()) requester.d_setFriendsList(requester.getFriendsList()) del self.requests[context]
def enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # Tell FriendsManager somebody is logging off: self.csm.air.friendsManager.toonOffline(self.avId) # Clear off POSTREMOVE: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES) self.csm.air.send(dg) # Remove avatar channel: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) # Reset sender channel: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target<<32) # accountId in high 32 bits, no avatar in low self.csm.air.send(dg) # Unload avatar object: dg = PyDatagram() dg.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) dg.addUint32(self.avId) self.csm.air.send(dg) # Done! self.csm.air.writeServerEvent('avatarUnload', self.avId) try: del self.csm.account2username[channel] except KeyError: self.csm.notify.warning('Unload avatar: %s not in account2username??' % channel) self.demand('Off')
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. dgcleanup = PyDatagram() dgcleanup.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) dgcleanup.addUint32(self.avId) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) # Activate the avatar on the DBSS: self.csm.air.sendActivate(self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) # Next, add them to the avatar channel: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target<<32 | self.avId) # accountId in high 32 bits, avatar in low self.csm.air.send(dg) # Finally, grant ownership and shut down. dg = PyDatagram() dg.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addChannel(self.target<<32 | self.avId) # accountId in high 32 bits, avatar in low self.csm.air.send(dg) # Tell TTFriendsManager somebody is logging in: self.csm.air.friendsManager.toonOnline(self.avId, self.avatar) # Tell the GlobalPartyManager as well self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEvent('avatarChosen', self.avId, self.target) self.demand('Off')
def enterSetAccount(self): # First, if there's anybody on the account, kill 'em for redundant login: dg = PyDatagram() dg.addServerHeader(self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) dg.addUint16(100) dg.addString('This account has been logged in elsewhere.') self.csm.air.send(dg) # Next, add this connection to the account channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(dg) # Now set their sender channel to represent their account affiliation: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.accountId << 32) # accountId in high 32 bits, 0 in low (no avatar) self.csm.air.send(dg) # Un-sandbox them! dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) # ESTABLISHED state. self.csm.air.send(dg) fields = {'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId)} if self.adminAccess != -1: fields.update({'ADMIN_ACCESS': self.adminAccess}) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], fields) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.databaseId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) self.csm.account2username[self.target] = self.username self.demand('Off')
def enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # Tell TTIFriendsManager somebody is logging off: self.csm.air.friendsManager.toonOffline(self.avId) # Clear off POSTREMOVE: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES) self.csm.air.send(datagram) # Remove avatar channel: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) # Reset sender channel: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target<<32) self.csm.air.send(datagram) # Unload avatar object: datagram = PyDatagram() datagram.addServerHeader( self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagram.addUint32(self.avId) self.csm.air.send(datagram) # Done! self.csm.air.writeServerEvent('avatarUnload', self.avId) self.demand('Off')
def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # First, give them a POSTREMOVE to unload the avatar, just in case they # disconnect while we're working. datagramCleanup = PyDatagram() datagramCleanup.addServerHeader( self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagramCleanup.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(datagramCleanup.getMessage()) self.csm.air.send(datagram) # Activate the avatar on the DBSS: self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)], 'setBankMoney': [self.account.get('MONEY', 0)]}) # Next, add them to the avatar channel: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target<<32 | self.avId) self.csm.air.send(datagram) # Eliminate race conditions. taskMgr.doMethodLater(0.2, self.enterSetAvatarTask, 'avatarTask-%s' % self.avId, extraArgs=[channel], appendTask=True)
def enterSetAccount(self): # If necessary, update their account information: if self.accessLevel: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'ACCESS_LEVEL': self.accessLevel}) # If there's anybody on the account, kill them for redundant login: datagram = PyDatagram() datagram.addServerHeader( self.csm.GetAccountConnectionChannel(self.accountId), self.csm.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in from elsewhere.') self.csm.air.send(datagram) # Next, add this connection to the account channel. datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetAccountConnectionChannel(self.accountId)) self.csm.air.send(datagram) # Add this connection to extra channels which may be useful: if self.accessLevel > 100: datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(OtpDoGlobals.OTP_STAFF_CHANNEL) self.csm.air.send(datagram) # Now set their sender channel to represent their account affiliation: datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) # Account ID in high 32 bits, 0 in low (no avatar): datagram.addChannel(self.accountId << 32) self.csm.air.send(datagram) # Un-sandbox them! datagram = PyDatagram() datagram.addServerHeader( self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) # ESTABLISHED self.csm.air.send(datagram) # Update the last login timestamp: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.userId)}) # We're done. self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.userId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', [int(time.time())]) self.demand('Off')
def claimOwnership(self, channelId): datagram = PyDatagram() datagram.addServerHeader(channelId, self.ourChannel, STATESERVER_OBJECT_SET_AI) datagram.addChannel(self.ourChannel) self.send(datagram)