def enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) 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) self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ACCESS_LEVEL', 100)]}) datagram = PyDatagram() datagram.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(datagram) 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) taskMgr.doMethodLater(0.2, self.enterSetAvatarTask, 'avatarTask-%s' % self.avId, extraArgs=[channel], appendTask=True)
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 enterSetAccount(self): # First, if there's anybody on the account, kill 'em for redundant login: dg = PyDatagram() dg.addServerHeader(self.csm.GetAccountConnectionChannel(int(self.databaseId)), 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.databaseId)) 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.databaseId << 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. BIG FAT SECURITY RISK!!! self.csm.air.send(dg) # We're done. self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def __handleSetAvatar(self): channel = self.loginManager.GetAccountConnectionChannel(self.sender) cleanupDatagram = PyDatagram() cleanupDatagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) cleanupDatagram.addUint32(self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) datagram.addString(cleanupDatagram.getMessage()) self.loginManager.air.send(datagram) self.loginManager.air.sendActivate(self.avId, 0, 0, self.loginManager.air.dclassesByName['DistributedToonUD']) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel(self.loginManager.GetPuppetConnectionChannel(self.avId)) self.loginManager.air.send(datagram) self.loginManager.air.clientAddSessionObject(channel, self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.sender << 32 | self.avId) # accountId in high 32 bits, avatar in low. self.loginManager.air.send(datagram) self.loginManager.air.setOwner(self.avId, channel) self._handleDone()
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 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 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) self.demand('Off')
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 __handleUnloadAvatar(self): channel = self.loginManager.GetAccountConnectionChannel(self.sender) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES) self.loginManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL) datagram.addChannel( self.loginManager.GetPuppetConnectionChannel(self.avId)) self.loginManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel( self.sender << 32) # accountId in high 32 bits, no avatar in low. self.loginManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.loginManager.air.ourChannel, CLIENTAGENT_REMOVE_SESSION_OBJECT) datagram.addUint32(self.avId) self.loginManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagram.addUint32(self.avId) self.loginManager.air.send(datagram) self._handleDone()
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 enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # Fire off the avatarOffline message. self.csm.air.netMessenger.send("avatarOffline", [self.avId]) # Get lost, POST_REMOVES!: 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("avatar-unload", avId=self.avId) self.demand("Off")
def enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) self.csm.air.friendsManager.toonOffline(self.avId) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target << 32) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_REMOVE_SESSION_OBJECT) dg.addUint32(self.avId) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) dg.addUint32(self.avId) self.csm.air.send(dg) self.csm.air.writeServerEvent('avatar-unload', avId=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)]}) # 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 enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) 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 enterSetAccount(self): if self.accessLevel: self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], {'ACCESS_LEVEL': self.accessLevel}) 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) 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) access = self.account.get('ACCESS_LEVEL', 0) if access >= 200: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 400: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) if access >= 500: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_SYSADMIN_CHANNEL) self.csm.air.send(dg) datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.accountId << 32) self.csm.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) datagram.addUint16(2) self.csm.air.send(datagram) 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) }) self.csm.air.writeServerEvent('accountLogin', self.target, self.accountId, self.userId) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', [int(time.time())]) self.demand('Off')
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 enterSetAccount(self): # If somebody's already logged into this account, disconnect them. datagram = PyDatagram() datagram.addServerHeader( self.gameServicesManager.GetAccountConnectionChannel( self.accountId), self.gameServicesManager.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(OTPGlobals.BootedReason["loggedInElsewhere"]) datagram.addString('This account has been logged into elsewhere.') self.gameServicesManager.air.send(datagram) # Now we'll add this connection to the account channel. datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.gameServicesManager.GetAccountConnectionChannel( self.accountId)) self.gameServicesManager.air.send(datagram) # Set their sender channel to represent their account affiliation. datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel( self.accountId << 32) # accountId in high 32 bits, 0 in low (no avatar). self.gameServicesManager.air.send(datagram) # We can now un-sandbox the sender. self.gameServicesManager.air.setClientState(self.target, 2) # ESTABLISHED state. # Update the last login timestamp. self.gameServicesManager.air.dbInterface.updateObject( self.gameServicesManager.air.dbId, self.accountId, self.gameServicesManager.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId), 'ACCESS_LEVEL': self.accessLevel }) # We're done. self.gameServicesManager.air.writeServerEvent('account-login', clientId=self.target, accId=self.accountId, dbId=self.databaseId, playToken=self.playToken) # Send the acceptLogin update through the GameServicesManager & set this operation's state to Off. self.gameServicesManager.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def enterUnloadAvatar(self): # Get the client channel. channel = self.gameServicesManager.GetAccountConnectionChannel( self.target) # Tell the friends manager that we're logging off. self.gameServicesManager.air.ttoffFriendsManager.goingOffline( self.avId) # First, remove our POST_REMOVES. datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES) self.gameServicesManager.air.send(datagram) # Next, remove the avatar channel. datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL) datagram.addChannel( self.gameServicesManager.GetPuppetConnectionChannel(self.avId)) self.gameServicesManager.air.send(datagram) # Next, reset the sender channel. datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel( self.target << 32) # accountId in high 32 bits, no avatar in low. self.gameServicesManager.air.send(datagram) # Reset the session object. datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_REMOVE_SESSION_OBJECT) datagram.addUint32(self.avId) self.gameServicesManager.air.send(datagram) # Unload the avatar object. datagram = PyDatagram() datagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagram.addUint32(self.avId) self.gameServicesManager.air.send(datagram) # We're done! We can now shut down this operation. self.gameServicesManager.air.writeServerEvent('avatar-unloaded', avId=self.avId) self.demand('Off')
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 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 enterSetAccount(self): # First, 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) # 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(time.mktime(time.gmtime())), '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.mktime(time.gmtime()))]) 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 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 __handleSetAccount(self): # if somebody's already logged into this account, disconnect them datagram = PyDatagram() datagram.addServerHeader( self.loginManager.GetAccountConnectionChannel(self.accountId), self.loginManager.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(100) datagram.addString('This account has been logged in elsewhere.') self.loginManager.air.send(datagram) # add connection to account channel datagram = PyDatagram() datagram.addServerHeader(self.sender, self.loginManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.loginManager.GetAccountConnectionChannel(self.accountId)) self.loginManager.air.send(datagram) # set sender channel to represent account affiliation datagram = PyDatagram() datagram.addServerHeader(self.sender, self.loginManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel( self.accountId << 32) # accountId is in high 32 bits, 0 in low (no avatar). self.loginManager.air.send(datagram) # set client state to established, thus un-sandboxing the sender self.loginManager.air.setClientState(self.sender, 2) responseData = { 'returnCode': 0, 'respString': '', 'accountNumber': self.sender, 'createFriendsWithChat': 'YES', 'chatCodeCreationRule': 'YES', 'access': 'FULL', 'WhiteListResponse': 'YES', 'lastLoggedInStr': self.getLastLoggedInStr(), 'accountDays': self.getAccountDays(), 'serverTime': int(time.time()), 'toonAccountType': 'NO_PARENT_ACCOUNT', 'userName': str(self.databaseId) } responseBlob = json.dumps(responseData) self.loginManager.sendUpdateToChannel(self.sender, 'loginResponse', [responseBlob]) self._handleDone()
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 enterSetAccount(self): # First, 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) # 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(time.mktime(time.gmtime())), '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.mktime(time.gmtime()))]) 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): # 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 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 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 enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # 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 enterSetAccount(self): 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) 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) access = self.account.get('ADMIN_ACCESS', 0) if access >= 400: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 500: dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.accountId << 32) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_SET_STATE) dg.addUint16(2) self.csm.air.send(dg) self.csm.air.dbInterface.updateObject( self.csm.air.dbId, self.accountId, self.csm.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId), 'ADMIN_ACCESS': self.adminAccess }) self.csm.air.writeServerEvent('account-login', clientId=self.target, accId=self.accountId, webAccId=self.databaseId, cookie=self.cookie) self.csm.sendUpdateToChannel(self.target, 'acceptLogin', []) 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)]}) # 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) # 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 TTRFriendsManager 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 handleConnected(self): ToontownInternalRepository.handleConnected(self) # Generate our district... self.districtId = self.allocateChannel() self.notify.info('Creating district (%d)...' % self.districtId) self.district = ToontownDistrictAI(self) self.district.setName(self.districtName) self.district.generateWithRequiredAndId(self.districtId, self.getGameDoId(), OTP_ZONE_ID_MANAGEMENT) # Claim ownership of that district... 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) # Create our local objects. self.notify.info('Creating local objects...') self.createLocals() # Create our global objects. self.notify.info('Creating global objects...') self.createGlobals() # Create our zones. self.notify.info('Creating zones (Playgrounds and Cog HQs)...') self.createZones() # Make our district available, and we're done. self.notify.info('Get your districts in, and...') self.district.b_setAvailable(1) self.notify.info( 'Districts are now complete. NOW PLAY TOONTOWN MYSTERY OR ELSE!!!!!!' )
def enterSetAccount(self): datagram = PyDatagram() datagram.addServerHeader( self.gameServicesManager.GetAccountConnectionChannel( self.accountId), self.gameServicesManager.air.ourChannel, CLIENTAGENT_EJECT) datagram.addUint16(OTPGlobals.BootedLoggedInElsewhere) datagram.addString('This account has been logged into elsewhere.') self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) datagram.addChannel( self.gameServicesManager.GetAccountConnectionChannel( self.accountId)) self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.target, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.accountId << 32) self.gameServicesManager.air.send(datagram) self.gameServicesManager.air.setClientState(self.target, 2) self.gameServicesManager.air.dbInterface.updateObject( self.gameServicesManager.air.dbId, self.accountId, self.gameServicesManager.air.dclassesByName['AccountUD'], { 'LAST_LOGIN': time.ctime(), 'ACCOUNT_ID': str(self.databaseId), 'ACCESS_LEVEL': self.accessLevel }) self.gameServicesManager.air.writeServerEvent('account-login', clientId=self.target, accId=self.accountId, dbId=self.databaseId, playToken=self.playToken) self.gameServicesManager.sendUpdateToChannel(self.target, 'acceptLogin', []) self.demand('Off')
def enterUnloadAvatar(self): channel = self.gameServicesManager.GetAccountConnectionChannel( self.target) self.gameServicesManager.air.ttoffFriendsManager.goingOffline( self.avId) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_CLEAR_POST_REMOVES) self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_CLOSE_CHANNEL) datagram.addChannel( self.gameServicesManager.GetPuppetConnectionChannel(self.avId)) self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) datagram.addChannel(self.target << 32) self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(channel, self.gameServicesManager.air.ourChannel, CLIENTAGENT_REMOVE_SESSION_OBJECT) datagram.addUint32(self.avId) self.gameServicesManager.air.send(datagram) datagram = PyDatagram() datagram.addServerHeader(self.avId, channel, STATESERVER_OBJECT_DELETE_RAM) datagram.addUint32(self.avId) self.gameServicesManager.air.send(datagram) simbase.air.banManager.removeClient(self.target) self.gameServicesManager.air.writeServerEvent('avatar-unloaded', avId=self.avId) self.demand('Off')
def handleConnected(self): ToontownInternalRepository.handleConnected(self) if self.holidayPasscode != '': self.initServerHoliday() self.districtId = self.allocateChannel() self.notify.info('Creating district (%d)...' % self.districtId) self.distributedDistrict = ToontownDistrictAI(self) self.distributedDistrict.setName(self.districtName) self.distributedDistrict.setDescription(self.serverDescription) self.distributedDistrict.setHolidayPasscode(self.holidayValue) self.distributedDistrict.generateWithRequiredAndId( self.districtId, self.getGameDoId(), OTP_ZONE_ID_MANAGEMENT) 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()
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) # Get the avatar's "true" access. (without "server" bit) adminAccess = self.account.get('ADMIN_ACCESS', 0) adminAccess = adminAccess - adminAccess % 100 # 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.csm.GetAccountConnectionChannel(self.target)) # Set ownership channel to the connection's account channel. self.csm.air.send(dg) # Tell the GlobalPartyManager as well: self.csm.air.globalPartyMgr.avatarJoined(self.avId) # Tell everything that an avatar is coming online! friendsList = [x for x, y in self.avatar['setFriendsList'][0]] self.csm.air.netMessenger.send('avatarOnline', [self.avId, friendsList]) # Post-remove for an avatar that disconnects unexpectedly. dgcleanup = self.csm.air.netMessenger.prepare('avatarOffline', [self.avId]) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) self.csm.air.writeServerEvent('avatar-chosen', avId=self.avId, accId=self.target) self.demand('Off')
def enterUnloadAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) # Fire off the avatarOffline message. self.csm.air.netMessenger.send('avatarOffline', [self.avId]) # Get lost, POST_REMOVES!: 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('avatar-unload', avId=self.avId) self.demand('Off')
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 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 TTRFriendsManager 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 enterSetAvatar(self): channel = self.csm.GetAccountConnectionChannel(self.target) 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) adminAccess = self.account.get('ADMIN_ACCESS', 0) adminAccess = adminAccess - adminAccess % 100 self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedToonUD'], {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(self.csm.GetPuppetConnectionChannel(self.avId)) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_ADD_SESSION_OBJECT) dg.addUint32(self.avId) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(channel, self.csm.air.ourChannel, CLIENTAGENT_SET_CLIENT_ID) dg.addChannel(self.target << 32 | self.avId) self.csm.air.send(dg) dg = PyDatagram() dg.addServerHeader(self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) dg.addChannel(self.csm.GetAccountConnectionChannel(self.target)) self.csm.air.send(dg) fields = self.avatar fields.update( {'setAdminAccess': [self.account.get('ADMIN_ACCESS', 0)]}) self.csm.air.friendsManager.toonOnline(self.avId, fields) self.csm.air.globalPartyMgr.avatarJoined(self.avId) self.csm.air.writeServerEvent('avatar-chosen', avId=self.avId, accId=self.target) self.demand('Off')
def inventorySetup(self, inventoryId): channel = self.csm.GetAccountConnectionChannel(self.target) # Activate the avatar on the DBSS: self.csm.air.sendActivate( self.avId, 0, 0, self.csm.air.dclassesByName['DistributedPlayerPirateUD'], { 'setInventoryId': (inventoryId,)}) # 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) # Claim ownership of the avatar's inventory datagram = PyDatagram() datagram.addServerHeader( self.avId, self.csm.air.ourChannel, STATESERVER_OBJECT_SET_OWNER) datagram.addChannel(inventoryId) 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): # 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) # Subscribe to any "staff" channels that the account has access to. access = self.account.get("ADMIN_ACCESS", 0) if access >= 200: # Subscribe to the moderator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 400: # Subscribe to the administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) if access >= 500: # Subscribe to the system administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_SYSADMIN_CHANNEL) 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. BIG FAT SECURITY RISK!!! self.csm.air.send(dg) # 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": self.databaseId, "ADMIN_ACCESS": self.adminAccess, "BETA_KEY_QUEST": self.betaKeyQuest, }, ) # Add a POST_REMOVE to the connection channel to execute the NetMessenger # message when the account connection goes RIP on the Client Agent. dgcleanup = self.csm.air.netMessenger.prepare("accountDisconnected", [self.accountId]) dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_ADD_POST_REMOVE) dg.addString(dgcleanup.getMessage()) self.csm.air.send(dg) # We're done. self.csm.air.writeServerEvent( "account-login", clientId=self.target, accId=self.accountId, webAccId=self.databaseId, cookie=self.cookie ) self.csm.sendUpdateToChannel(self.target, "acceptLogin", []) 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)
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) # Subscribe to any "staff" channels that the account has access to. access = self.account.get('ADMIN_ACCESS', 0) if access >= 200: # Subscribe to the moderator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_MOD_CHANNEL) self.csm.air.send(dg) if access >= 400: # Subscribe to the administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_ADMIN_CHANNEL) self.csm.air.send(dg) if access >= 500: # Subscribe to the system administrator channel. dg = PyDatagram() dg.addServerHeader(self.target, self.csm.air.ourChannel, CLIENTAGENT_OPEN_CHANNEL) dg.addChannel(OtpDoGlobals.OTP_SYSADMIN_CHANNEL) self.csm.air.send(dg) # 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(), 'LAST_LOGIN_TS': time.time(), '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')