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
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 __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)
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)
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)
