def __init__(self): self._http_client = HTTPClient() max_http_requests = ConfigVariableInt('http-max-requests', 900).value self._request_allocator = UniqueIdAllocator(0, max_http_requests) self._poll_task = None self._requests = {}
def reportMemoryLeaks(): if printUnreachableNum() == 0: return import bz2, gc gc.set_debug(gc.DEBUG_SAVEALL) gc.collect() uncompressedReport = '' for s in gc.garbage: try: uncompressedReport += str(s) + '&' except TypeError: pass reportdata = bz2.compress(uncompressedReport, 9) headers = {'Content-type': 'application/x-bzip2', 'Accept': 'text/plain'} try: baseURL = patcherVer()[0].split('/lo')[0] except IndexError: print 'Base URL not available for leak submit' return basePort = 80 if baseURL.count(':') == 2: basePort = baseURL[-4:] baseURL = baseURL[:-5] baseURL = baseURL[7:] if basePort != 80: finalURL = 'http://' + baseURL + ':' + str(basePort) + '/logging/memory_leak.php?leakcount=' + str(printUnreachableNum()) else: finalURL = 'http://' + baseURL + '/logging/memory_leak.php?leakcount=' + str(printUnreachableNum()) reporthttp = HTTPClient() reporthttp.postForm(URLSpec(finalURL), reportdata)
class ToontownRPCClient: notify = directNotify.newCategory('ToontownRPCClient') def __init__(self, endpoint): self.url = URLSpec(endpoint) self.http = HTTPClient() self.http.setVerifySsl(0) self.channels = {} # Start polling: taskName = self.getUniqueName() + '-pollTask' taskMgr.add(self.pollTask, taskName) def __getattr__(self, item): return ToontownRPCMethod(self, item) def getUniqueName(self): return 'ToontownRPCClient-' + str(id(self)) def pollOnce(self): for channel, method in self.channels.items(): if not channel.run(): del self.channels[channel] method.finish() def pollTask(self, task): self.pollOnce() return task.cont
def getFunnelURL(self): if patcherVer() == ['OFFLINE']: return if patcherVer() == []: patcherHTTP = HTTPClient() if checkParamFile() == None: patcherDoc = patcherHTTP.getDocument(URLSpec('http://download.toontown.com/english/currentVersion/content/patcher.ver')) vconGroup('w', self.cgRelease) else: patcherDoc = patcherHTTP.getDocument(URLSpec(checkParamFile())) vconGroup('w', self.cgBeta) rf = Ramfile() patcherDoc.downloadToRam(rf) self.patcherURL = rf.getData() if self.patcherURL.find('FUNNEL_LOG') == -1: patcherVer('w', 'OFFLINE') return self.patcherURL = self.patcherURL.split('\n') del rf del patcherDoc del patcherHTTP while self.patcherURL: self.confLine = self.patcherURL.pop() if self.confLine.find('FUNNEL_LOG=') != -1 and self.confLine.find('#FUNNEL_LOG=') == -1: self.dynamicVRFunnel = self.confLine[11:].strip('\n') patcherVer('w', self.confLine[11:].strip('\n')) else: self.dynamicVRFunnel = patcherVer()[0] return
def __init__(self, endpoint): self.url = URLSpec(endpoint) self.http = HTTPClient() self.http.setVerifySsl(0) self.channels = {} # Start polling: taskName = self.getUniqueName() + '-pollTask' taskMgr.add(self.pollTask, taskName)
def ban(self, avatarId, dislid, comment): parameters = '' parameters += 'app=%s' % self.App parameters += '&product=%s' % self.Product parameters += '&user_id=%s' % dislid parameters += '&event_name=%s' % self.EventName commentWithAvatarId = 'avId-%s ' % avatarId commentWithAvatarId += comment parameters += '&comments=%s' % urllib.quote(str(commentWithAvatarId)) baseUrlToUse = self.BanUrl osBaseUrl = os.getenv('BAN_URL') if osBaseUrl: baseUrlToUse = osBaseUrl fullUrl = baseUrlToUse + '?' + parameters self.notify.info('ban request %s dislid=%s comment=%s fullUrl=%s' % (self.curBanRequestNum, dislid, comment, fullUrl)) simbase.air.writeServerEvent('ban_request', avatarId, '%s|%s|%s' % (dislid, comment, fullUrl)) if simbase.config.GetBool('do-actual-ban', True): newTaskName = 'ban-task-%d' % self.curBanRequestNum newTask = taskMgr.add(self.doBanUrlTask, newTaskName) newTask.banRequestNum = self.curBanRequestNum http = HTTPClient.getGlobalPtr() channel = http.makeChannel(False) self.channels[self.curBanRequestNum] = channel rf = Ramfile() self.ramFiles[self.curBanRequestNum] = rf channel.beginGetDocument(fullUrl) channel.downloadToRam(rf) self.curBanRequestNum += 1
def redownloadNews(self): if self.redownloadingNews: self.notify.warning( 'averting potential crash redownloadNews called twice, just returning' ) return else: self.percentDownloaded = 0.0 self.notify.info('starting redownloadNews') self.startRedownload = datetime.datetime.now() self.redownloadingNews = True self.addDownloadingTextTask() for issue in self.issues: issue.destroy() self.issues = [] self.curIssueIndex = 0 self.strFilenames = None self.needsParseNews = True self.newsUrl = self.getInGameNewsUrl() self.newsDir = Filename(self.findNewsDir()) Filename(self.newsDir + '/.').makeDir() http = HTTPClient.getGlobalPtr() self.url = self.newsUrl + self.NewsIndexFilename self.ch = http.makeChannel(True) self.ch.beginGetDocument(self.url) self.rf = Ramfile() self.ch.downloadToRam(self.rf) taskMgr.remove(self.RedownloadTaskName) taskMgr.add(self.downloadIndexTask, self.RedownloadTaskName) return
def redownloadNews(self): if self.redownloadingNews: self.notify.warning('averting potential crash redownloadNews called twice, just returning') return self.percentDownloaded = 0.0 self.notify.info('starting redownloadNews') self.startRedownload = datetime.datetime.now() self.redownloadingNews = True self.addDownloadingTextTask() for issue in self.issues: issue.destroy() self.issues = [] self.curIssueIndex = 0 self.strFilenames = None self.needsParseNews = True self.newsUrl = self.getInGameNewsUrl() self.newsDir = Filename(self.findNewsDir()) Filename(self.newsDir + '/.').makeDir() http = HTTPClient.getGlobalPtr() self.url = self.newsUrl + self.NewsIndexFilename self.ch = http.makeChannel(True) self.ch.beginGetDocument(self.url) self.rf = Ramfile() self.ch.downloadToRam(self.rf) taskMgr.remove(self.RedownloadTaskName) taskMgr.add(self.downloadIndexTask, self.RedownloadTaskName) return
def _FancyLoadingScreen__setAdArt(self): return None imageFrame = self.model.find('**/frame') randomImageNumber = random.randint(0, len(screenShots) - 1) imageFileName = screenShots[randomImageNumber] self.adImage = loader.loadModel(imageFileName) self.adImage.reparentTo(imageFrame) self.adImage.setScale(2.1499999999999999 * 5, 1, 1.2 * 5) self.adImage.setPos(0, 0, 2.2999999999999998) self.adImage.setBin('fixed', 1) if randomImageNumber == 0: urlToGet = 'http://log.go.com/log?srvc=dis&guid=951C36F8-3ACD-4EB2-9F02-8E8A0A217AF5&drop=0&addata=3232:64675:408091:64675&a=0' self.httpSession = HTTPClient() self.nonBlockHTTP = self.httpSession.makeChannel(False) self.nonBlockHTTP.beginGetDocument(DocumentSpec(urlToGet)) instanceMarker = 'FunnelLoggingRequest-%s' % str(random.randint(1, 1000)) self.startCheckingAsyncRequest(instanceMarker)
class HTTPRest(object): """ Primary class for handling GET/POST requests with Panda's HTTPClient object """ notify = directNotify.newCategory('http-rest') def __init__(self): self._http_client = HTTPClient() max_http_requests = ConfigVariableInt('http-max-requests', 900).value self._request_allocator = UniqueIdAllocator(0, max_http_requests) self._poll_task = None self._requests = {} def setup(self): """ Performs setup operations on the http rest object """ self._poll_task = taskMgr.add( self.__update, '%s-update-task' % self.__class__.__name__) def __update(self, task): """ Performs update operations on the PandaHTTP instance """ for request_id in list(self._requests): # Check that this id is still valid if request_id not in self._requests: continue request = self._requests[request_id] request.update() return task.cont def destroy(self): """ Performs destruction operations on the PandaHTTP instance """ if self._poll_task: taskMgr.remove(self._poll_task) for request_id in list(self._requests): self.remove_request(request_id) def remove_request(self, request_id): """ Removes the request id form the PandaHTTP request list """ if request_id not in self._requests: return self._request_allocator.free(request_id) del self._requests[request_id] def get_request_status(self, request_id): """ Returns the requests current status """ return not request_id in self._requests def get_request(self, request_id): """ Returns the requested request if its present """ return self._requests.get(request_id, None) def perform_get_request(self, url, headers={}, content_type=None, callback=None): """ Performs an HTTP restful GET call and returns the request's unique itentifier """ self.notify.debug('Sending GET request: %s' % url) request_channel = self._http_client.make_channel(True) if content_type != None: request_channel.set_content_type(content_type) for header_key in headers: header_value = headers[header_key] request_channel.send_extra_header(header_key, header_value) request_channel.begin_get_document(DocumentSpec(url)) ram_file = Ramfile() request_channel.download_to_ram(ram_file, False) request_id = self._request_allocator.allocate() http_request = HTTPRequest(self, request_id, request_channel, ram_file, callback) self._requests[request_id] = http_request return request_id def perform_json_get_request(self, url, headers={}, callback=None): """ """ def json_wrapper(data): """ Wraps the callback to automatically perform json.load on the resulting data """ try: data = json.loads(data) except: self.notify.warning('Received invalid JSON results: %s' % data) callback(data) return self.perform_get_request(url=url, content_type='application/json', headers=headers, callback=json_wrapper) def perform_post_request(self, url, headers={}, content_type=None, post_body={}, callback=None): """ """ self.notify.debug('Sending POST request: %s' % url) request_channel = self._http_client.make_channel(True) if content_type != None: request_channel.set_content_type(content_type) for header_key in headers: header_value = headers[header_key] request_channel.send_extra_header(header_key, header_value) post_body = json.dumps(post_body) request_channel.begin_post_form(DocumentSpec(url), post_body) ram_file = Ramfile() request_channel.download_to_ram(ram_file, False) request_id = self._request_allocator.allocate() http_request = HTTPRequest(self, request_id, request_channel, ram_file, callback) self._requests[request_id] = http_request return request_id def perform_json_post_request(self, url, headers={}, post_body={}, callback=None): """ """ def json_wrapper(data): """ Wraps the callback to automatically perform json.load on the resulting data """ try: data = json.loads(data) except: self.notify.warning('Received invalid JSON results: %s' % data) callback(data) return self.perform_post_request(url=url, content_type='application/json', headers=headers, post_body=post_body, callback=json_wrapper)
def __init__(self): self.hitboxAcct = 'DM53030620EW' self.language = 'en-us' self.cgRoot = 'ToonTown_Online' self.cgBeta = 'Beta' self.cgRelease = 'Release' self.cgLocation = 'US' self.campaignID = '' self.cfCookieFile = 'cf.txt' self.dynamicVRFunnel = 'http://download.toontown.com/' self.hostDict = {0: 'Internal Disney PHP Collector Site', 1: 'ehg-dig.hitbox.com/HG?', 2: 'ehg-dig.hitbox.com/HG?', 3: 'build64.online.disney.com:5020/index.php?'} self.CurrentHost = '' self.URLtoSend = '' self.gameName = 'ToonTown' self.browserName = 'Panda3D%20(' + self.gameName + ';%20' + sys.platform + ')' self.HTTPUserHeader = [('User-agent', 'Panda3D')] self.osMajorver = '' self.osMinorver = '' self.osRevver = '' self.osBuild = '' self.osType = '' self.osComments = '' self.msWinTypeDict = {0: 'Win32s on Windows 3.1', 1: 'Windows 95/98/ME', 2: 'Windows NT/2000/XP', 3: 'Windows CE'} self.milestoneDict = {0: 'New User', 1: 'Create Account', 2: 'View EULA', 3: 'Accept EULA', 4: 'Download Start', 5: 'Download End', 6: 'Installer Run', 7: 'Launcher Start', 8: 'Launcher Login', 9: 'Client Opens', 10: 'Create Pirate Loads', 11: 'Create Pirate Exit', 12: 'Cutscene One Start', 13: 'Cutscene One Ends', 14: 'Cutscene Two Start', 15: 'Cutscene Thee Start', 16: 'Cutscene Three Ends', 17: 'Access Cannon', 18: 'Cutscene Four Starts', 19: 'Cutscene Four Ends', 20: 'Dock - Start Game'} self.macTypeDict = {2: 'Jaguar', 1: 'Puma', 3: 'Panther', 4: 'Tiger', 5: 'Lepard'} self.milestone = '' self.pandaHTTPClientVarWSS = [] self.pandaHTTPClientVarCTG = [] self.pandaHTTPClientVarDM = [] self.checkForCFfile() self.httpSession = HTTPClient() self.whatOSver()
class UserFunnel: def __init__(self): self.hitboxAcct = 'DM53030620EW' self.language = 'en-us' self.cgRoot = 'ToonTown_Online' self.cgBeta = 'Beta' self.cgRelease = 'Release' self.cgLocation = 'US' self.campaignID = '' self.cfCookieFile = 'cf.txt' self.dynamicVRFunnel = 'http://download.toontown.com/' self.hostDict = {0: 'Internal Disney PHP Collector Site', 1: 'ehg-dig.hitbox.com/HG?', 2: 'ehg-dig.hitbox.com/HG?', 3: 'build64.online.disney.com:5020/index.php?'} self.CurrentHost = '' self.URLtoSend = '' self.gameName = 'ToonTown' self.browserName = 'Panda3D%20(' + self.gameName + ';%20' + sys.platform + ')' self.HTTPUserHeader = [('User-agent', 'Panda3D')] self.osMajorver = '' self.osMinorver = '' self.osRevver = '' self.osBuild = '' self.osType = '' self.osComments = '' self.msWinTypeDict = {0: 'Win32s on Windows 3.1', 1: 'Windows 95/98/ME', 2: 'Windows NT/2000/XP', 3: 'Windows CE'} self.milestoneDict = {0: 'New User', 1: 'Create Account', 2: 'View EULA', 3: 'Accept EULA', 4: 'Download Start', 5: 'Download End', 6: 'Installer Run', 7: 'Launcher Start', 8: 'Launcher Login', 9: 'Client Opens', 10: 'Create Pirate Loads', 11: 'Create Pirate Exit', 12: 'Cutscene One Start', 13: 'Cutscene One Ends', 14: 'Cutscene Two Start', 15: 'Cutscene Thee Start', 16: 'Cutscene Three Ends', 17: 'Access Cannon', 18: 'Cutscene Four Starts', 19: 'Cutscene Four Ends', 20: 'Dock - Start Game'} self.macTypeDict = {2: 'Jaguar', 1: 'Puma', 3: 'Panther', 4: 'Tiger', 5: 'Lepard'} self.milestone = '' self.pandaHTTPClientVarWSS = [] self.pandaHTTPClientVarCTG = [] self.pandaHTTPClientVarDM = [] self.checkForCFfile() self.httpSession = HTTPClient() self.whatOSver() def checkForCFfile(self): if firstRun() == True: pass elif os.path.isfile(self.cfCookieFile) == False: firstRun('write', True) def whatOSver(self): if sys.platform == 'win32': self.osMajorver = str(sys.getwindowsversion()[0]) self.osMinorver = str(sys.getwindowsversion()[1]) self.osBuild = str(sys.getwindowsversion()[2]) self.osType = str(sys.getwindowsversion()[3]) self.osComments = str(sys.getwindowsversion()[4]) return if sys.platform == 'darwin': self.osMajorver = '10' osxcmd = '/usr/sbin/system_profiler SPSoftwareDataType |/usr/bin/grep "System Version"' infopipe = os.popen(osxcmd, 'r') parseLine = infopipe.read() infopipe.close() del infopipe notify.info('parseLine = %s' % str(parseLine)) versionStringStart = parseLine.find('10.') notify.info('versionStringStart = %s' % str(versionStringStart)) testPlist = False try: self.osMinorver = parseLine[versionStringStart + 3] self.osRevver = parseLine[versionStringStart + 5:versionStringStart + 7].strip(' ') self.osBuild = parseLine[int(parseLine.find('(')) + 1:parseLine.find(')')] except: notify.info("couldn't parse the system_profiler output, using zeros") self.osMinorver = '0' self.osRevver = '0' self.osBuild = '0000' testPlist = True del versionStringStart del parseLine del osxcmd if testPlist: try: import plistlib pl = plistlib.readPlist('/System/Library/CoreServices/SystemVersion.plist') notify.info('pl=%s' % str(pl)) parseLine = pl['ProductVersion'] numbers = parseLine.split('.') notify.info('parseline =%s numbers =%s' % (parseLine, numbers)) self.osMinorver = numbers[1] self.osRevver = numbers[2] self.osBuild = pl['ProductBuildVersion'] except: notify.info('tried plist but still got exception') self.osMinorver = '0' self.osRevver = '0' self.osBuild = '0000' return def setmilestone(self, ms): if firstRun() == False: self.milestone = ms else: self.milestone = '%s_INITIAL' % ms def setgamename(self, gamename): self.gameName = gamename def printosComments(self): return self.osComments def setHost(self, hostID): self.CurrentHost = hostID def getFunnelURL(self): if patcherVer() == ['OFFLINE']: return if patcherVer() == []: patcherHTTP = HTTPClient() if checkParamFile() == None: patcherDoc = patcherHTTP.getDocument(URLSpec('http://download.toontown.com/english/currentVersion/content/patcher.ver')) vconGroup('w', self.cgRelease) else: patcherDoc = patcherHTTP.getDocument(URLSpec(checkParamFile())) vconGroup('w', self.cgBeta) rf = Ramfile() patcherDoc.downloadToRam(rf) self.patcherURL = rf.getData() if self.patcherURL.find('FUNNEL_LOG') == -1: patcherVer('w', 'OFFLINE') return self.patcherURL = self.patcherURL.split('\n') del rf del patcherDoc del patcherHTTP while self.patcherURL: self.confLine = self.patcherURL.pop() if self.confLine.find('FUNNEL_LOG=') != -1 and self.confLine.find('#FUNNEL_LOG=') == -1: self.dynamicVRFunnel = self.confLine[11:].strip('\n') patcherVer('w', self.confLine[11:].strip('\n')) else: self.dynamicVRFunnel = patcherVer()[0] return def isVarSet(self, varInQuestion): try: tempvar = type(varInQuestion) return 1 except NameError: return 0 def buildURL(self): if sys.platform == 'win32': hitboxOSType = 'c3' else: hitboxOSType = 'c4' if self.CurrentHost == 1: self.URLtoSend = 'http://' + self.hostDict[self.CurrentHost] + 'hb=' + str(self.hitboxAcct) + '&n=' + str(self.milestone) + '&ln=' + self.language + '&gp=STARTGAME&fnl=TOONTOWN_FUNNEL&vcon=/' + self.cgRoot + '/' + self.cgLocation + '/' + str(vconGroup()) + '&c1=' + str(sys.platform) + '&' + str(hitboxOSType) + '=' + str(self.osMajorver) + '_' + str(self.osMinorver) + '_' + str(self.osRevver) + '_' + str(self.osBuild) if self.CurrentHost == 2: self.URLtoSend = 'http://' + self.hostDict[self.CurrentHost] + 'hb=' + str(self.hitboxAcct) + '&n=' + str(self.milestone) + '&ln=' + self.language + '&vcon=/' + self.cgRoot + '/' + self.cgLocation + '/' + str(vconGroup()) + '&c1=' + str(sys.platform) + '&' + str(hitboxOSType) + '=' + str(self.osMajorver) + '_' + str(self.osMinorver) + '_' + str(self.osRevver) + '_' + str(self.osBuild) if self.CurrentHost == 0: localMAC = str(getMAC()) self.URLtoSend = str(self.dynamicVRFunnel) + '?funnel=' + str(self.milestone) + '&platform=' + str(sys.platform) + '&sysver=' + str(self.osMajorver) + '_' + str(self.osMinorver) + '_' + str(self.osRevver) + '_' + str(self.osBuild) + '&mac=' + localMAC + '&username='******'&id=' + str(loggingAvID()) def readInPandaCookie(self): thefile = open(self.cfCookieFile, 'r') thedata = thefile.read().split('\n') thefile.close() del thefile if thedata[0].find('Netscape HTTP Cookie File') != -1: return thedata.pop() try: while thedata: temp = thedata.pop() temp = temp.split('\t') domain = temp[0] loc = temp[1] variable = temp[2] value = temp[3] if variable == 'CTG': self.pandaHTTPClientVarCTG = [domain, loc, variable, value] self.setTheHTTPCookie(self.pandaHTTPClientVarCTG) if variable == self.hitboxAcct + 'V6': self.pandaHTTPClientVarDM = [domain, loc, variable, value] self.setTheHTTPCookie(self.pandaHTTPClientVarDM) if variable == 'WSS_GW': self.pandaHTTPClientVarWSS = [domain, loc, variable, value] self.setTheHTTPCookie(self.pandaHTTPClientVarWSS) except IndexError: print 'UserFunnel(Warning): Cookie Data file bad' del thedata def updateInstanceCookieValues(self): a = self.httpSession.getCookie(HTTPCookie('WSS_GW', '/', '.hitbox.com')) if a.getName(): self.pandaHTTPClientVarWSS = ['.hitbox.com', '/', 'WSS_GW', a.getValue()] b = self.httpSession.getCookie(HTTPCookie('CTG', '/', '.hitbox.com')) if b.getName(): self.pandaHTTPClientVarCTG = ['.hitbox.com', '/', 'CTG', b.getValue()] c = self.httpSession.getCookie(HTTPCookie(self.hitboxAcct + 'V6', '/', 'ehg-dig.hitbox.com')) if c.getName(): self.pandaHTTPClientVarDM = ['ehg-dig.hitbox.com', '/', self.hitboxAcct + 'V6', c.getValue()] del a del b del c def setTheHTTPCookie(self, cookieParams): c = HTTPCookie(cookieParams[2], cookieParams[1], cookieParams[0]) c.setValue(cookieParams[3]) self.httpSession.setCookie(c) def writeOutPandaCookie(self): try: thefile = open(self.cfCookieFile, 'w') if len(self.pandaHTTPClientVarWSS) == 4: thefile.write(self.pandaHTTPClientVarWSS[0] + '\t' + self.pandaHTTPClientVarWSS[1] + '\t' + self.pandaHTTPClientVarWSS[2] + '\t' + self.pandaHTTPClientVarWSS[3] + '\n') if len(self.pandaHTTPClientVarCTG) == 4: thefile.write(self.pandaHTTPClientVarCTG[0] + '\t' + self.pandaHTTPClientVarCTG[1] + '\t' + self.pandaHTTPClientVarCTG[2] + '\t' + self.pandaHTTPClientVarCTG[3] + '\n') if len(self.pandaHTTPClientVarDM) == 4: thefile.write(self.pandaHTTPClientVarDM[0] + '\t' + self.pandaHTTPClientVarDM[1] + '\t' + self.pandaHTTPClientVarDM[2] + '\t' + self.pandaHTTPClientVarDM[3] + '\n') thefile.close() except IOError: return def prerun(self): self.getFunnelURL() self.buildURL() if os.path.isfile(self.cfCookieFile) == True: if self.CurrentHost == 1 or self.CurrentHost == 2: self.readInPandaCookie() def run(self): if self.CurrentHost == 0 and patcherVer() == ['OFFLINE']: return self.nonBlock = self.httpSession.makeChannel(False) self.nonBlock.beginGetDocument(DocumentSpec(self.URLtoSend)) instanceMarker = str(random.randint(1, 1000)) instanceMarker = 'FunnelLoggingRequest-%s' % instanceMarker self.startCheckingAsyncRequest(instanceMarker) def startCheckingAsyncRequest(self, name): taskMgr.remove(name) taskMgr.doMethodLater(0.5, self.pollFunnelTask, name) def stopCheckingFunnelTask(self, name): taskMgr.remove('pollFunnelTask') def pollFunnelTask(self, task): result = self.nonBlock.run() if result == 0: self.stopCheckingFunnelTask(task) if self.CurrentHost == 1 or self.CurrentHost == 2: self.updateInstanceCookieValues() self.writeOutPandaCookie() else: return Task.again
class FancyLoadingScreen(DirectObject.DirectObject): notify = DirectNotifyGlobal.directNotify.newCategory('LoadingScreen') def __init__(self, parent): DirectObject.DirectObject.__init__(self) self.debugMode = config.GetInt('loading-screen') == 2 self.parent = parent self.state = False self.currScreenshot = None self.snapshot = None self.snapshotFrame = None self.snapshotFrameBasic = None self.currentTime = 0 self.analyzeMode = False self.loadScale = 1.0 self.unmappedTicks = [] self.stepInfo = { } self.accept(base.win.getWindowEvent(), self.adjustSize) self.accept('tick', self.tick) self.currStage = 'unmapped' self.stagePercent = 0 self.numObjects = 0 self.currPercent = 0.0 self.line = LineSegs() self.line.setColor((0, 0, 0, 1)) self.line.setThickness(1) self.stageLabel = None self.currNum = 0 self.overallPercent = 0 self.lastPercent = 0 self.topLock = aspect2dp.attachNewNode('topShift') self.root = self.topLock.attachNewNode('loadingScreenRoot') self.root.setZ(-1) self.root.stash() self.model = loader.loadModel('models/gui/pir_m_gui_gen_loadScreen.bam') self.model.setP(90) self.model.reparentTo(self.root) cm = CardMaker('backdrop') cm.setFrame(-10, 10, -10, 10) if self.debugMode: self.backdrop = self.root.attachNewNode(cm.generate()) self.backdrop.setX(-1.5) self.backdrop.setZ(-1) self.backdrop.setScale(4) self.backdrop.setColor(0.5, 0.5, 0.5, 1) cm = CardMaker('loadingBarBase') cm.setFrame(-0.90000000000000002, 0.90000000000000002, 0.10000000000000001, 0.5) self.loadingBarBacking = self.root.attachNewNode(cm.generate()) self.loadingBarRoot = self.root.attachNewNode('loadingBarRoot') cm.setName('analysisBarBase') cm.setFrame(-0.90000000000000002, 0.90000000000000002, -0.5, -0.10000000000000001) self.analysisBar = self.root.attachNewNode(cm.generate()) self.analysisBarRoot = self.root.attachNewNode('analysisBarRoot') self.analysisBar.hide() self.analysisButtons = [] self.enterToContinue = DirectLabel(parent = self.root, text = 'Press Shift To Continue', relief = None, text_scale = 0.10000000000000001, pos = (0, 0, -0.90000000000000002), text_align = TextNode.ACenter) self.enterToContinue.hide() self.stageLabel = DirectLabel(parent = self.root, text = '', relief = None, text_scale = 0.10000000000000001, pos = (-1.25, 0, 0.75), text_align = TextNode.ALeft, textMayChange = 1) self.tickLabel = DirectLabel(parent = self.root, text = '', relief = None, text_scale = 0.10000000000000001, pos = (0.75, 0, 0.75), textMayChange = 1) self.overallLabel = DirectLabel(parent = self.root, text = '', relief = None, text_scale = 0.10000000000000001, pos = (0, 0, -0.75), textMayChange = 1) else: self.backdrop = loader.loadModel('models/gui/pir_m_gui_gen_loadScreen') self.backdrop.reparentTo(self.root) bg = self.backdrop.find('**/expandable_bg') bg.setScale(1000, 1, 1000) bg.flattenStrong() self.backdrop.find('**/loadbar_grey').setColorScale(0.14999999999999999, 0.14999999999999999, 0.14999999999999999, 0.10000000000000001) self.loadingBar = self.backdrop.find('**/loadbar') self.loadingBar.setColorScale(0.20000000000000001, 0.59999999999999998, 0.5, 1) self.loadingPlank = NodePathCollection() self.loadingPlank.addPath(self.backdrop.find('**/plank_loading_bar')) self.loadingPlank.addPath(self.backdrop.find('**/loadbar')) self.loadingPlank.addPath(self.backdrop.find('**/loadbar_frame')) self.loadingPlank.addPath(self.backdrop.find('**/loadbar_grey')) self.titlePlank = self.backdrop.find('**/plank_title') self.percentLabel = DirectLabel(text = '0%', parent = self.root, relief = None, text_font = PiratesGlobals.getPirateFont(), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, text_scale = 0.031, pos = (0, 0, -0.44450000000000001), textMayChange = 1) self.loadingPlank.addPath(self.percentLabel) self.screenshot = self.backdrop.find('**/screenshot') copyGeom = self.loadingBar.find('**/+GeomNode').node().getGeom(0) format = copyGeom.getVertexData().getFormat() primitive = copyGeom.getPrimitive(0) data = GeomVertexData(self.screenshot.node().getGeom(0).getVertexData()) data.setFormat(format) writer = GeomVertexWriter(data, 'texcoord') writer.setData2f(0, 0) writer.setData2f(1, 0) writer.setData2f(1, 1) writer.setData2f(0, 1) geom = Geom(data) geom.addPrimitive(primitive) self.screenshot.node().removeGeom(0) self.screenshot.node().addGeom(geom) self.titlePlankMiddle = self.backdrop.find('**/plank_title_middle_box') self.titlePlankLeft = self.backdrop.find('**/plank_title_left') self.titlePlankRight = self.backdrop.find('**/plank_title_right') self.loadingBarColors = [ (((i % 10) / 10.0 + 0.5) / 2.0, ((i % 100) / 10 / 10.0 + 0.5) / 2.0, (i / 100 / 10.0 + 0.5) / 2.0, 1) for i in range(1000) ] random.shuffle(self.loadingBarColors) self.lastUpdateTime = globalClock.getRealTime() self.locationLabel = DirectLabel(parent = self.root, relief = None, text = '', text_font = PiratesGlobals.getPirateOutlineFont(), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, text_scale = PiratesGuiGlobals.TextScaleTitleJumbo * 0.69999999999999996, text_align = TextNode.ACenter, pos = (0.0, 0.0, 0.51500000000000001), textMayChange = 1) self.locationText = None self.hintLabel = DirectLabel(parent = self.root, relief = None, text = '', text_font = PiratesGlobals.getPirateOutlineFont(), text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, text_scale = PiratesGuiGlobals.TextScaleTitleJumbo * 0.5, text_align = TextNode.ACenter, pos = (0.0, 0.0, -0.62), text_wordwrap = 30, textMayChange = 1) self.hintText = None self.adImage = None self.allowLiveFlatten = ConfigVariableBool('allow-live-flatten') self.title_art = [] self.tempVolume = [] self.adjustSize(base.win) gsg = base.win.getGsg() if gsg: self.root.prepareScene(gsg) def startLoading(self, expectedLoadScale): if not self.debugMode: self.loadingBar.setSx(0) self.loadScale = float(expectedLoadScale) self.currStage = 'unmapped' self.stagePercent = 0 self.numObjects = 0 self.currPercent = 0.0 self.loadingStart = globalClock.getRealTime() self.currNum = 0 self.overallPercent = 0 self.lastPercent = 0 self.stepNum = 0 if self.debugMode: self.overallLabel['text'] = '0.0' self.stageLabel['text'] = self.currStage self.update() def beginStep(self, stageName, amt = 0, percent = 0.001): if not self.state: return None if self.currStage != 'unmapped' and stageName != self.currStage: if __dev__ and self.debugMode: self.notify.error('step %s not finished when step %s was started!' % (self.currStage, stageName)) else: self.notify.warning('step %s not finished when step %s was started!' % (self.currStage, stageName)) return None self.stepNum += 1 if self.debugMode: stageColor = self.loadingBarColors[self.stepNum] self.stepInfo[stageName] = [ globalClock.getRealTime() - self.loadingStart, 0.0, stageColor, [], self.lastPercent + self.stagePercent, percent, amt] self.stepCard = CardMaker('step-%s' % stageName) self.stepCard.setColor(stageColor) self.currPoly = NodePath('empty') self.stageLabel['text'] = stageName self.tickLabel['text'] = '0.0' self.currPercent = 0.0 self.overallPercent = min(100.0 * self.loadScale, self.lastPercent + self.stagePercent) self.lastPercent = self.overallPercent self.currStage = stageName self.stagePercent = percent self.numObjects = amt self.currNum = 0 base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() def endStep(self, stageName): if self.currStage == 'unmapped': self.notify.warning('step %s was started before loading screen was enabled' % stageName) return None if stageName != self.currStage: if __dev__ and self.debugMode: self.notify.error('step %s was active while step %s was trying to end!' % (self.currStage, stageName)) else: return None self.tick() if self.debugMode: stageInfo = self.stepInfo[self.currStage] stageInfo[1] = globalClock.getRealTime() - self.loadingStart - stageInfo[0] self.currPoly.detachNode() self.stepCard.setFrame((self.lastPercent / self.loadScale) * 0.017999999999999999 - 0.90000000000000002, ((self.lastPercent + self.stagePercent) / self.loadScale) * 0.017999999999999999 - 0.90000000000000002, 0.10000000000000001, 0.5) self.loadingBarRoot.attachNewNode(self.stepCard.generate()) self.stageLabel['text'] = 'unmapped' self.currStage = 'unmapped' self.currPercent = 0.0 def tick(self): if self.state == False or self.analyzeMode: return None if self.debugMode: if self.currStage == 'unmapped': self.unmappedTicks.append(globalClock.getRealTime() - self.loadingStart) else: self.stepInfo[self.currStage][3].append(globalClock.getRealTime() - self.loadingStart) self.currNum += 1 self.currPercent = min(1.0, self.currNum / float(self.numObjects + 1)) self.overallPercent = min(100.0 * self.loadScale, self.lastPercent + self.currPercent * self.stagePercent) self.update() def destroy(self): taskMgr.remove('updateLoadingScreen') for part in (self.model, self.snapshot): if part is not None: tex = part.findTexture('*') if tex: tex.releaseAll() part.removeNode() self.model = None self.snapshot = None if self.snapshotFrame: self.snapshotFrame.destroy() if self.snapshotFrameBasic: self.snapshotFrameBasic.destroy() if self.locationLabel: self.locationLabel.destroy() if self.hintLabel: self.hintLabel.destroy() if self.debugMode: self.stageLabel.destroy() self.tickLabel.destroy() self.overallLabel.destroy() self.enterToContinue.destroy() self.stageLabel = None self.tickLabel = None self.overallLabel = None self.enterToContinue = None self.ignoreAll() def showTitleFrame(self): if base.config.GetBool('no-loading-screen', 0): return None for part in self.title_art: part.show() def hideTitleFrame(self): for part in self.title_art: part.hide() def show(self, waitForLocation = False, disableSfx = True, expectedLoadScale = 1.0): if self.state and base.config.GetBool('no-loading-screen', 0) or not (self.locationLabel): return None render.hide() render2d.hide() render2dp.hide() if not self.debugMode: self.loadingPlank.hide() self.root.unstash() self.root.showThrough() self.state = True gsg = base.win.getGsg() if gsg: gsg.setIncompleteRender(False) base.setTaskChainNetNonthreaded() self.allowLiveFlatten.setValue(1) self.startLoading(expectedLoadScale) base.graphicsEngine.renderFrame() base.graphicsEngine.renderFrame() base.refreshAds() taskMgr.add(self.update, 'updateLoadingScreen', priority = -100) if base.sfxManagerList and disableSfx: index = 0 while index < len(base.sfxManagerList): sfx_manager = base.sfxManagerList[index] sfx_manager.setVolume(0.0) index += 1 if base.appRunner: base.appRunner.notifyRequest('onLoadingMessagesStart') self._FancyLoadingScreen__setLocationText(self.locationText) self._FancyLoadingScreen__setHintText(self.hintText) if not waitForLocation: screenshot = random.choice(tutorialShots_MoveAim) self._FancyLoadingScreen__setLoadingArt(screenshot) def showHint(self, destId = None, ocean = False): if base.config.GetBool('no-loading-screen', 0) or not (self.locationLabel): return None if ocean: hint = getOceanHint() elif hasattr(base, 'localAvatar'): totalReputation = 0 level = base.localAvatar.getLevel() if totalReputation: hint = getHint(destId, level) else: hint = getHint(destId) else: hint = getHint() shipPVPIslands = [ '1196970035.53sdnaik', '1196970080.56sdnaik'] if (destId in shipPVPIslands or ocean) and base.localAvatar.getCurrentIsland() in shipPVPIslands: hint = getPrivateeringHint() if self.parent and base.localAvatar.style.getTutorial() == PiratesGlobals.TUT_MET_JOLLY_ROGER: hint = '%s: %s' % (PLocalizer.LoadingScreen_Hint, PLocalizer.GeneralTip7) self._FancyLoadingScreen__setHintText(hint) def update(self, task = None): if not (self.state) or self.analyzeMode: return Task.cont realTime = globalClock.getRealTime() if realTime - self.lastUpdateTime < 0.10000000000000001: return Task.cont self.currentTime += min(10, (realTime - self.lastUpdateTime) * 250) self.lastUpdateTime = realTime if self.debugMode: self.overallLabel['text'] = '%3.1f' % (self.overallPercent / self.loadScale) self.tickLabel['text'] = '%3.1f' % (self.currPercent * 100.0) else: self.percentLabel['text'] = '%d%%' % (self.overallPercent / self.loadScale) if self.currStage != 'unmapped': if self.debugMode: self.currPoly.detachNode() self.stepCard.setFrame((self.lastPercent / self.loadScale) * 0.017999999999999999 - 0.90000000000000002, (self.overallPercent / self.loadScale) * 0.017999999999999999 - 0.90000000000000002, 0.20000000000000001, 0.40000000000000002) self.currPoly = self.loadingBarRoot.attachNewNode(self.stepCard.generate()) if not self.debugMode: self.loadingBar.setSx((self.overallPercent / self.loadScale) * 3.3999999999999999) if self.overallPercent > 0: self.loadingPlank.show() base.eventMgr.doEvents() base.graphicsEngine.renderFrame() return Task.cont def hide(self, reallyHide = not (config.GetInt('loading-screen', 0) == 2)): if not self.state: return None if not reallyHide: if not self.analyzeMode: self.loadingEnd = globalClock.getRealTime() self.accept('shift', self.hide, extraArgs = [ 1]) self.enterToContinue.show() self.generateAnalysis() return None self.cleanupLoadingScreen() if self.debugMode: self.enterToContinue.hide() self.ignore('shift') self.root.hide() self.root.stash() render2d.show() render2dp.show() render.show() base.graphicsEngine.renderFrame() self.state = False self.currentTime = 0 self.locationText = None self.hintText = None self.currScreenshot = None gsg = base.win.getGsg() if gsg: gsg.setIncompleteRender(True) render.prepareScene(gsg) render2d.prepareScene(gsg) taskMgr.remove('updateLoadingScreen') self.allowLiveFlatten.clearValue() base.setTaskChainNetThreaded() if base.sfxManagerList: index = 0 while index < len(base.sfxManagerList): sfx_manager = base.sfxManagerList[index] sfx_manager.setVolume(base.options.sound_volume) index += 1 messenger.send('texture_state_changed') if base.appRunner: base.appRunner.notifyRequest('onLoadingMessagesStop') def showTarget(self, targetId = None, ocean = False, jail = False, pickapirate = False, exit = False, potionCrafting = False, benchRepair = False, shipRepair = False, cannonDefense = False, fishing = False): if base.config.GetBool('no-loading-screen', 0): return None if pickapirate: screenshot = screenShot_EnterGame elif exit: screenshot = screenShot_ExitGame elif ocean: screenshot = screenShot_Dinghy elif jail: screenshot = screenShot_Jail elif potionCrafting: screenshot = screenShot_Potions elif benchRepair: screenshot = screenShot_BenchRepair elif shipRepair: screenshot = screenShot_ShipRepair elif cannonDefense: screenshot = screenShot_CannonDefense elif fishing: screenshot = screenShot_Fishing elif base.localAvatar.style.getTutorial() < PiratesGlobals.TUT_GOT_CUTLASS: screenshot = screenShot_Weapon elif base.localAvatar.style.getTutorial() < PiratesGlobals.TUT_MET_JOLLY_ROGER: screenshot = screenShot_Cutlass elif base.cr.newsManager and base.cr.newsManager.getHoliday(21): screenshot = screenShots_WinterHolidayLocations.get(targetId) if not screenshot: screenshot = screenShots_Locations.get(targetId) else: screenshot = screenShots_Locations.get(targetId) if not screenshot: if areaType_Jungles.has_key(targetId): screenshot = random.choice(screenShots_Jungles) elif areaType_Swamps.has_key(targetId): screenshot = random.choice(screenShots_Swamps) elif areaType_Caves.has_key(targetId): screenshot = random.choice(screenShots_Caves) else: island = getParentIsland(targetId) screenshot = screenShots_Locations.get(island, [ random.choice(screenShots)])[0] if isinstance(screenshot, list): screenshot = random.choice(screenshot) self._FancyLoadingScreen__setLoadingArt(screenshot) if pickapirate: targetName = PLocalizer.LoadingScreen_PickAPirate elif exit: targetName = None elif ocean: targetName = PLocalizer.LoadingScreen_Ocean elif jail: targetName = PLocalizer.LoadingScreen_Jail else: targetName = PLocalizer.LocationNames.get(targetId) base.setLocationCode('Loading: %s' % targetName) if targetName is None: return None if len(targetName): self._FancyLoadingScreen__setLocationText(targetName) def _FancyLoadingScreen__setLoadingArt(self, screenshot): if self.currScreenshot: return None if self.parent and hasattr(base, 'localAvatar') and base.localAvatar.style.getTutorial() < PiratesGlobals.TUT_MET_JOLLY_ROGER and screenshot not in tutorialShots: screenshot = random.choice(tutorialShots) try: self.currScreenshot = loader.loadModel(screenshot).findAllTextures()[0] except: self.currScreenshot = loader.loadModel(random.choice(screenshot)).findAllTextures()[0] if not self.debugMode: self.screenshot.setTexture(self.currScreenshot) def _FancyLoadingScreen__setLocationText(self, locationText): if self.debugMode: return None self.locationText = locationText if not self.locationText: self.locationText = '' self.titlePlank.hide() if len(self.locationText) > 12: scaleFactor = len(self.locationText) / 12.0 self.titlePlankMiddle.setSx(scaleFactor) self.titlePlankRight.setX(0.215 * scaleFactor - 0.215) self.titlePlankLeft.setX(-1 * (0.215 * scaleFactor - 0.215)) else: self.titlePlankMiddle.setSx(1) self.titlePlankRight.setX(0) self.titlePlankLeft.setX(0) self.locationLabel['text'] = self.locationText if self._FancyLoadingScreen__isVisible() and len(self.locationText): self.locationLabel.show() self.titlePlank.show() else: self.locationLabel.hide() self.titlePlank.hide() launcher.setValue('gameLocation', self.locationText) def _FancyLoadingScreen__setHintText(self, hintText): self.hintText = hintText if not self.hintText: self.hintText = '' self.hintLabel['text'] = self.hintText if self._FancyLoadingScreen__isVisible(): self.hintLabel.show() def _FancyLoadingScreen__isVisible(self): return self.state def scheduleHide(self, function): base.cr.queueAllInterestsCompleteEvent() self.acceptOnce(function, self.interestComplete) def interestComplete(self): self.endStep('scheduleHide') self.hide() def _FancyLoadingScreen__setAdArt(self): return None imageFrame = self.model.find('**/frame') randomImageNumber = random.randint(0, len(screenShots) - 1) imageFileName = screenShots[randomImageNumber] self.adImage = loader.loadModel(imageFileName) self.adImage.reparentTo(imageFrame) self.adImage.setScale(2.1499999999999999 * 5, 1, 1.2 * 5) self.adImage.setPos(0, 0, 2.2999999999999998) self.adImage.setBin('fixed', 1) if randomImageNumber == 0: urlToGet = 'http://log.go.com/log?srvc=dis&guid=951C36F8-3ACD-4EB2-9F02-8E8A0A217AF5&drop=0&addata=3232:64675:408091:64675&a=0' self.httpSession = HTTPClient() self.nonBlockHTTP = self.httpSession.makeChannel(False) self.nonBlockHTTP.beginGetDocument(DocumentSpec(urlToGet)) instanceMarker = 'FunnelLoggingRequest-%s' % str(random.randint(1, 1000)) self.startCheckingAsyncRequest(instanceMarker) def startCheckingAsyncRequest(self, name): taskMgr.remove(name) taskMgr.doMethodLater(0.5, self.pollAdTask, name) def pollAdTask(self, task): result = self.nonBlockHTTP.run() if result == 0: self.stopCheckingAdTask(task) else: return Task.again def stopCheckingAdTask(self, name): taskMgr.remove(name) def cleanupLoadingScreen(self): if self.debugMode: self.loadingBarRoot.removeChildren() self.cleanupAnalysis() self.stepInfo = { } self.unmappedTicks = [] def showInfo(self, stepName, pos): self.stageLabel['text'] = stepName info = self.stepInfo[stepName] self.tickLabel['text'] = '%s ticks(%s)' % (len(info[3]), info[6]) self.overallLabel['text'] = '%3.2f seconds (%d%%)' % (info[1], 100 * info[1] / (self.loadingEnd - self.loadingStart)) def generateAnalysis(self): if self.analyzeMode: self.cleanupAnalysis() self.analyzeMode = True cm = CardMaker('cm') self.analysisBar.show() loadingTime = self.loadingEnd - self.loadingStart for stepName in self.stepInfo: (startTime, duration, color, ticks, startPercent, percent, expectedTicks) = self.stepInfo[stepName] cm.setName(stepName) cm.setColor(color) cm.setFrame((startTime / loadingTime) * 1.8 - 0.90000000000000002, ((startTime + duration) / loadingTime) * 1.8 - 0.90000000000000002, -0.5, -0.10000000000000001) self.analysisBarRoot.attachNewNode(cm.generate()) button = DirectFrame(parent = self.analysisBarRoot, geom = NodePath('empty'), image = NodePath('empty'), state = DGG.NORMAL, relief = None, frameSize = ((startTime / loadingTime) * 1.8 - 0.90000000000000002, ((startTime + duration) / loadingTime) * 1.8 - 0.90000000000000002, -0.5, -0.10000000000000001)) button.bind(DGG.ENTER, self.showInfo, extraArgs = [ stepName]) self.analysisButtons.append(button) button = DirectFrame(parent = self.analysisBarRoot, geom = NodePath('empty'), image = NodePath('empty'), state = DGG.NORMAL, relief = None, frameSize = ((startPercent / self.loadScale / 100.0) * 1.8 - 0.90000000000000002, ((startPercent + percent) / self.loadScale / 100.0) * 1.8 - 0.90000000000000002, 0.10000000000000001, 0.5)) button.bind(DGG.ENTER, self.showInfo, extraArgs = [ stepName]) self.analysisButtons.append(button) for tick in ticks: self.line.moveTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.5)) self.line.drawTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.55000000000000004)) for tick in self.unmappedTicks: self.line.moveTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.5)) self.line.drawTo(VBase3((tick / loadingTime) * 1.8 - 0.90000000000000002, 0, -0.55000000000000004)) self.analysisSegs = self.analysisBarRoot.attachNewNode(self.line.create()) def cleanupAnalysis(self): for button in self.analysisButtons: button.destroy() self.analysisButtons = [] self.analysisBarRoot.removeChildren() self.analysisBar.hide() self.analyzeMode = False self.analysisSegs = None def adjustSize(self, window): x = max(1, window.getXSize()) y = max(1, window.getYSize()) minSz = min(x, y) aspect = float(x) / y if x > y: self.topLock.setZ(1) else: self.topLock.setZ(float(y) / x) if minSz > IDEALX: self.topLock.setScale(IDEALX / float(x)) elif minSz > IDEALY: self.topLock.setScale(IDEALY / float(y)) else: self.topLock.setScale(1.0)