def setFullscreen(): """Helper function to set the window fullscreen with width and height set to the screens size""" # set window properties # clear all properties not previously set base.win.clearRejectedProperties() # setup new window properties props = WindowProperties() # Fullscreen props.setFullscreen(True) # set the window size to the screen resolution props.setSize(self.dispWidth, self.dispHeight) # request the new properties base.win.requestProperties(props) # Set the config variables so we correctly store the # new size and fullscreen setting later winSize = ConfigVariableString("win-size") winSize.setValue("{} {}".format(self.dispWidth, self.dispHeight)) fullscreen = ConfigVariableBool("fullscreen") fullscreen.setValue(True) # Render a frame to make sure the fullscreen is applied # before we do anything else self.taskMgr.step() # make sure to propagate the new aspect ratio properly so # the GUI and other things will be scaled appropriately aspectRatio = self.dispWidth / self.dispHeight self.adjustWindowAspectRatio(aspectRatio)
class graphica : elements = None #drawing elements map_zoom = 1 map_pos = (0, 0) width = 0 height = 0 title_update_time = 0.5 p3d = None #Panda Engine flat = None #floor of the world screen = None #screen surface def __init__(self, params, pipe, dir): self.game_directory = dir self.game_pipe = pipe self.gs_window = ConfigVariableString('win-size') self.gs_window.setValue(str(params.get('width', 800)) +' '+str(params.get('height', 600))) self.gs_multi = ConfigVariableBool('framebuffer-multisample') self.gs_multi.setValue(params.get('multisample', 1)) self.gs_sync = ConfigVariableBool('sync-video', str(params.get('sync', 1))) self.gs_sync.setValue(params.get('sync', 1)) loadPrcFileData('', 'win-size '+ str(params.get('width', 800)) +' '+str(params.get('height', 600))) loadPrcFileData('', 'win-fixed-size 1') loadPrcFileData('', 'text-default-font data/HanZi.ttf') loadPrcFileData('', 'multisamples ' + str(params.get('samples', 0))) #loadPrcFileData('', 'fullscreen 1') #loadPrcFileData('', 'textures-power-2 pad') #loadPrcFileData('', 'notify-level spam') #loadPrcFileData('', 'default-directnotify-level spam') #loadPrcFileData('', 'notify-output I:\\Users\\User\\My Documents\\Aptana Studio 3 Workspace\\sg\\out2.txt') #nout = MultiplexStream() #Notify.ptr().setOstreamPtr(nout, 0) #nout.addFile(Filename("out.txt")) '''for i in xrange(ConfigVariableManager.getGlobalPtr().getNumVariables()): if ConfigVariableManager.getGlobalPtr().isVariableUsed(i) : name = ConfigVariableManager.getGlobalPtr().getVariableName(i) v = ConfigVariable(name) ''' self.p3d = ShowBase.ShowBase() self.p3d.buttonThrowers[0].node().setButtonDownEvent('buttonDown') self.p3d.buttonThrowers[0].node().setButtonRepeatEvent('buttonRep') self.p3d.buttonThrowers[0].node().setButtonUpEvent('buttonUp') self.p3d.accept('buttonDown', self.keyboard, [0,]) self.p3d.accept('buttonRep', self.keyboard, [2,]) self.p3d.accept('buttonUp', self.keyboard, [1,]) self.p3d.disableMouse() #Disable default mouse-based camera control self.screen = render2d.attachNewNode("Screen Coord Node") self.screen.setBin("fixed", 100) self.flat = render.attachNewNode("2d Objects in 3d world") self.flat.setBin('background', 0) self.flat.setDepthTest(False) self.flat.setDepthWrite(False) render.setAntialias(AntialiasAttrib.MAuto) self.props = WindowProperties(self.p3d.win.getProperties()) #Screen size self.width = params['width'] self.height = params['height'] self.aratio = float(self.width)/self.height #aspect ratio self.p3d.camera.setZ(1000) self.p3d.camera.lookAt(0,0,0) self.p3d.camLens.setFov(80) #self.props.setSize(size[0],size[1]) self.screen.setScale(2.0/self.width,1,2.0/self.height) self.dt = 0.0 self.fps = 0 self.title_last_update_time = 0 self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, 0)) self.elements = {} #self.MModel = self.create_model_xt((0,0,0), 'models\\chinesegfx_city_1_1.x', 'models\\houses_chinesegfx.tga', (3,3))[1] #self.MModel.reparentTo(hidden) #sys.stdout.flush() #self.p3d.taskMgr.run() #self.myShader = Shader.load(Shader.SLGLSL, "modules\\myvertexshader.glsl", "modules\\myfragmentshader.glsl") #self.plane2.setShader(self.myShader) self.mouse_pos = (0, 0) self.mouse_on_map_pos = (0, 0) self.p3d.accept('wheel_up',self.zoom_in) self.p3d.accept('wheel_down',self.zoom_out) self.p3d.accept('mouse1',self.mouse_click_left) self.p3d.accept('mouse3',self.mouse_click_right) self.parents = {} self.gui_surface = aspect2d.attachNewNode("GUI Node") self.gui_surface.setScale(2.0/self.height,1,2.0/self.height) self.gui_surface.setBin("fixed", 50) self.map_node = self.add_node('map_node', 'background', 0, self.flat) self.paths_node = self.add_node('paths_node', 'background', 3, self.flat) self.paths_all_node = self.add_node('paths_all_node', 'background', 3, self.flat) self.map_mode_node = self.add_node('map_mode_node', 'background', 1, self.map_node) self.selecties_node = self.add_node('selecties_node', 'background', 2, self.map_node) self.parents['render'] = render self.parents['gui_surface'] = self.gui_surface self.elements['city_map_model'] = self.create_model_xt(fname = 'models\\chinesegfx_city_1_1.x', texname = 'models\\houses_chinesegfx.tga', size = (3, 3), name = 'city_map_model') self.minimap = Minimap(self.width, self.height, self) def add_node(self, name, mode1, mode2, parent = None): node = None if parent == None : node = render.attachNewNode(name) else : node = parent.attachNewNode(name) if (mode1 <> None) and (mode2 <> None ): node.setBin(mode1, mode2) self.parents[name] = node self.elements[name] = node return node def get_parent(self, p): if p in self.parents : return self.parents[p] elif p in self.elements : return self.elements[p] else : return render def gr_loop(self): self.mouse_control() self.frame() def Start(self): print 'Starting graphic loop' sys.stdout.flush() while(1): #считывает отправленные данные start_time = globalClock.getRealTime() try: while self.game_pipe.poll(False) and ((globalClock.getRealTime() - start_time) < 0.5) : m = self.game_pipe.recv() try: if m[0] == 'setitem' : if m[1]['key'] == 'pos' : self.elements[m[1]['name']].setPos(m[1]['value']) elif m[1]['key'] == 'image' : self.elements[m[1]['name']]['image'] = textures.get(m[1]['value'], None) elif m[1]['key'] == 'scale' : self.elements[m[1]['name']].setScale(m[1]['value']) else : self.elements[m[1]['name']][m[1]['key']] = m[1]['value'] elif m[0] == 'set_map_pos' : self.set_map_pos(m[1][0], m[1][1]) elif m[0] == 'set_map_zoom' : self.set_map_zoom(m[1]) elif m[0] == 'draw_image2d' : self.draw_image2d(**m[1]) elif m[0] == 'draw_image' : self.draw_image(**m[1]) elif m[0] == 'draw_line' : self.draw_line(**m[1]) #continue elif m[0] == 'draw_line2d' : self.draw_line2d(**m[1]) elif m[0] == 'draw_circle' : self.draw_circle(**m[1]) elif m[0] == 'draw_triangles' : self.draw_triangles(**m[1]) elif m[0] == 'delete_el_mask' : self.delete_el_mask(m[1]) elif m[0] == 'delete_el' : self.delete_el(m[1]) elif m[0] == 'gui_hide' : self.elements[m[1]].hide() elif m[0] == 'gui_show' : self.elements[m[1]].show() elif m[0] == 'gui_removeAndDestroyAllItems' : self.elements[m[1]].removeAndDestroyAllItems() elif m[0] == 'reparentTo' : self.elements[m[1]].reparentTo( self.elements[m[2]] ) elif m[0] == 'setTexture' : self.elements[m[1]].setTexture(textures[m[2]]) elif m[0] == 'setPos' : self.elements[m[1]].setPos(m[2][0], m[2][1], m[2][2]) elif m[0] == 'setHpr' : self.elements[m[1]].setHpr(m[2][0], m[2][1], m[2][2]) elif m[0] == 'instanceTo' : self.elements[m[2]] = render.attachNewNode('Placeholder') self.elements[m[1]].instanceTo(self.elements[m[2]]) elif m[0] == 'resetFrameSize' : self.elements[m[1]].resetFrameSize() elif m[0] == 'setTransparency' : self.elements[m[1]].setTransparency(TransparencyAttrib.MAlpha) elif m[0] == 'RemoveGuiElement' : try: self.elements[m[1]].destroy() except: self.elements[m[1]].removeNode() elif m[0] == 'removeNode' : self.elements[m[1]].removeNode() elif m[0] == 'removeAllChildren' : self.elements[m[1]].node().removeAllChildren() elif m[0] == 'gui_addItem' : self.elements[m[1]].addItem(self.elements[m[2]]) elif m[0] == 'DirectLabel' : params = dict(m[1]) params['parent'] = self.get_parent(params.get('parent', 'render') ) self.elements[m[2]['name']] = DirectLabel(**params) elif m[0] == 'DirectButton' : params = dict(m[1]) params['parent'] = self.get_parent(params.get('parent', 'render') ) params['command'] = self.GUI_pressed params['extraArgs'] = (m[2]['name'],) self.elements[m[2]['name']] = DirectButton(**params) elif m[0] == 'DirectFrame' : params = dict(m[1]) params['parent'] = self.get_parent( params.get('parent', 'render') ) self.elements[m[2]['name']] = DirectFrame(**params) elif m[0] == 'DirectScrolledList' : params = dict(m[1]) params['parent'] = self.get_parent( params.get('parent', 'render') ) self.elements[m[2]['name']] = DirectScrolledList(**params) elif m[0] == 'DirectCheckButton' : params = dict(m[1]) params['parent'] = self.get_parent( params.get('parent', 'render') ) self.elements[m[2]['name']] = DirectCheckButton(**params) elif m[0] == 'DirectWaitBar' : params = dict(m[1]) params['parent'] = self.get_parent( params.get('parent', 'render') ) self.elements[m[2]['name']] = DirectWaitBar(**params) elif m[0] == 'create_actor_egg' : self.create_actor_egg(**m[1]) elif m[0] == 'anim_loop' : if len(m) == 3 : m = list(m) m.append({}) self.elements[m[1]].loop(m[2], **m[3]) elif m[0] == 'image_data_new' : t = PNMImage() #print 'RECV', m[2] sys.stdout.flush() if t.read(StringStream(m[2])) : pass else : raise ValueError() sys.stdout.flush() tex = Texture() tex.load(t) textures[m[1]] = tex elif m[0] == 'create_minimap' : im = PNMImage() self.elements['phyz'].getTexture().store(im) self.minimap.create_minimap(im, m[1], m[2]) self.draw_image2d(pos = (self.width/2 - 200, -self.height/2), texname = 'minimap_tex', name = 'minimap_image', parent = 'gui_surface' ) else : print 'Unknown command:', m sys.stdout.flush() #print m #sys.stdout.flush() except: print m print 'error1', sys.exc_info() sys.stdout.flush() except: print 'error2', sys.exc_info() sys.stdout.flush() try: self.gr_loop() except Exception: print 'error3', sys.exc_info() sys.stdout.flush() try: pass #if not(self.game_queue.full()): # self.game_queue.put(('mouse_pos', self.mouse_pos)) # self.game_queue.put(('mouse_on_map_pos', self.mouse_on_map_pos)) #else : # print 'game full' # sys.stdout.flush() except: print 'error4', sys.exc_info() sys.stdout.flush() sys.stdout.flush() #time.sleep(0.01) def GUI_pressed(self, name): self.game_pipe.send(('gui_pressed',name)) def mouse_control(self): if self.p3d.mouseWatcherNode.hasMouse(): mp = (self.p3d.mouseWatcherNode.getMouse()[0], 0, self.p3d.mouseWatcherNode.getMouse()[1]) self.mouse_pos[0] = self.screen.getRelativePoint(render2d, mp)[0] self.mouse_pos[1] = self.screen.getRelativePoint(render2d, mp)[2] self.ttt = globalClock.getRealTime() mpos = self.p3d.mouseWatcherNode.getMouse() tmp = self.scr_to_map(mpos) self.mouse_on_map_pos[0] = tmp[0] self.mouse_on_map_pos[1] = tmp[1] X_ = self.p3d.camera.getX() Y_ = self.p3d.camera.getY() C = 0.5*self.dt if self.mouse_pos[0] < self.width * -0.47 : X_ -= self.p3d.camera.getZ()*C self.minimap.update_pos() if self.mouse_pos[0] > self.width * 0.47 : X_ += self.p3d.camera.getZ()*C self.minimap.update_pos() if self.mouse_pos[1] < self.height * -0.47 : Y_ -= self.p3d.camera.getZ()*C self.minimap.update_pos() if self.mouse_pos[1] > self.height * 0.47 : Y_ += self.p3d.camera.getZ()*C self.minimap.update_pos() self.p3d.camera.setX( X_ ) self.p3d.camera.setY( Y_ ) def mouse_click_left(self): self.game_pipe.send(('mouse_click_left',)) def mouse_click_right(self): self.game_pipe.send(('mouse_click_right',)) def frame(self): self.p3d.taskMgr.step() self.dt = globalClock.getDt() if globalClock.getRealTime() - self.title_last_update_time > self.title_update_time : self.props = WindowProperties(self.p3d.win.getProperties()) self.title_last_update_time = globalClock.getRealTime() self.fps = globalClock.getAverageFrameRate() title = str(self.fps) + str(self.mouse_pos[:]) + str(self.mouse_on_map_pos[:]) self.props.setTitle(title) self.p3d.win.requestProperties(self.props) def draw_line(self, **kwargs): ps = kwargs.get('points',[]) name = '' if 'name' in kwargs.keys() : name = kwargs['name'] if self.check_name(name) : #print 'draw_line name duplicated', name return None else : name = self.generate_name() ls = LineSegs() if 'width' in kwargs.keys() : ls.setThickness( kwargs['width'] ) if 'color' in kwargs.keys() : ls.setColor( (kwargs['color'][0], kwargs['color'][1], kwargs['color'][2], kwargs['color'][3]) ) for i in ps : ls.drawTo(i[0], i[1], i[2]) node = ls.create() np = NodePath(node) if 'parent' in kwargs.keys() and kwargs['parent'] <> None : self.get_parent(kwargs['parent']).attachNewNode(np.node()) else : render.attachNewNode(np.node()) self.elements[ name ] = np return name, np def draw_line2d(self, **kwargs): ps = None if 'points' in kwargs.keys(): ps = kwargs['points'] else : return None name = '' if 'name' in kwargs.keys() : name = kwargs['name'] if self.check_name(name) : #print 'draw_line name duplicated', name return None else : name = self.generate_name() ls = LineSegs() if 'width' in kwargs.keys() : ls.setThickness( kwargs['width'] ) if 'color' in kwargs.keys() : ls.setColor( Vec4(kwargs['color'][0], kwargs['color'][1], kwargs['color'][2], kwargs['color'][3]) ) for i in ps : ls.drawTo(i[0], 0, i[1]) node = ls.create() np = NodePath(node) if 'parent' in kwargs.keys() and kwargs['parent'] <> None : self.get_parent(kwargs['parent']).attachNewNode(np.node()) else : self.screen.attachNewNode(np.node()) self.elements[ name ] = np return name, np def draw_circle(self, **kw):#x, color, r, width, name, prec = 10, parent = None, hpr = None): x = kw.get('pos',(0,0,0)) color = kw.get('color',(0,0,0,255)) r = kw.get('radius',5) width = kw.get('width',1) prec = kw.get('prec', 10) parent = self.get_parent(kw.get('parent', None)) hpr = kw.get('hpr', None) name = kw.get('name', self.generate_name()) if self.check_name(name) : #print 'draw_circle name duplicated', name return None ls = LineSegs() ls.setThickness( width ) ls.setColor( Vec4(float(color[0])/256,float(color[1])/256,float(color[2])/256,float(color[3])/256) ) for i in xrange(prec) : angle = math.pi*i*2/prec ls.drawTo(x[0] + math.sin(angle) * r, x[1] + math.cos(angle) * r,0) ls.drawTo(x[0] + math.sin(math.pi*i*2/1) * r, x[1] + math.cos(math.pi*i*2/1) * r, 0) node = ls.create() np = NodePath(node) if color[3] <> 255 : np.setTransparency(TransparencyAttrib.MAlpha) if hpr <> None : np.setHpr(hpr[0],hpr[1],hpr[2]) if parent == None : self.flat.attachNewNode(np.node()) else : parent.attachNewNode(np.node()) self.elements[name] = np def draw_circle2d(self, x, color, r, width, name, prec = 10, parent = None): ls = LineSegs() ls.setThickness( width ) ls.setColor( Vec4(float(color[0])/256,float(color[1])/256,float(color[2])/256,float(color[3])/256) ) for i in xrange(prec) : angle = math.pi*i*2/prec ls.drawTo(x[0] + math.sin(angle) * r, 0, x[1] + math.cos(angle) * r) ls.drawTo(x[0] + math.sin(math.pi*i*2/1) * r, 0, x[1] + math.cos(math.pi*i*2/1) * r) node = ls.create() np = NodePath(node) if parent == None : self.screen.attachNewNode(np.node()) else : parent.attachNewNode(np.node()) self.elements[name] = np def draw_text(self,msg,x,rgba,size,font = 'HanZi.ttf', surface = None): pass def draw_image(self,pos = (0,0,0), fname = '', name = None, scale = (1,1), size = None, parent = None, image = None, **kw): if name == None : name = self.generate_name() tex = Texture() texname = kw.get('texname', None) if texname <> None : if texname in textures.keys() : tex.load(textures[texname]) else : tex = loader.loadTexture(texname) else : return None, None xframe = tex.getXSize() if tex.getOrigFileXSize() <> 0 : xframe = tex.getOrigFileXSize() yframe = tex.getYSize() if tex.getOrigFileYSize() <> 0 : yframe = tex.getOrigFileYSize() if size <> None : scale = (float(scale[0]) * size[0]/tex.getOrigFileXSize(), float(scale[1]) * size[1]/tex.getOrigFileYSize() ) cm = CardMaker('card') cm.setFrame(0,xframe*scale[0],0,yframe*scale[1]) card = None if parent == None : card = render.attachNewNode(cm.generate()) else : card = self.get_parent(parent).attachNewNode(cm.generate()) card.setTexture(tex) card.setPos(pos[0],pos[1],pos[2]) card.setHpr(0,-90,0) self.elements[name] = card return name, card def draw_polygon(self,ps,color,name): color = ( float(color[0])/255, float(color[1])/255, float(color[2])/255, float(color[3])/255) vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic) vwriter = GeomVertexWriter(vdata, 'vertex') #cwriter = GeomVertexWriter(vdata, 'color') trig = Triangulator() for i in ps : vi = trig.addVertex(i[0], i[1]) vwriter.addData3f(i[0], i[2], i[1]) #cwriter.addData4f(color[0], color[1], color[2], color[3]) trig.addPolygonVertex(vi) trig.triangulate() prim = GeomTriangles(Geom.UHStatic) for i in range(trig.getNumTriangles()): prim.addVertices(trig.getTriangleV0(i), trig.getTriangleV1(i), trig.getTriangleV2(i)) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) geomNode = GeomNode('trig') geomNode.addGeom(geom) np = NodePath(geomNode) np.reparentTo(render) #fill=self.screen.attachNewNode(geomNode) #fill.analyze() self.elements[name] = np def draw_tristrips(self, ps, color, name, parent = None): vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic) vwriter = GeomVertexWriter(vdata, 'vertex') for i in ps : vwriter.addData3f(i[0], i[1], i[0]) prim = GeomTristrips(Geom.UHStatic) for i in range(len(ps)) : prim.addVertex(i) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) geomNode = GeomNode('trig') geomNode.addGeom(geom) np = NodePath(geomNode) if parent == None : render.attachNewNode(np.node()) else : parent.attachNewNode(np.node()) #fill=self.screen.attachNewNode(geomNode) #fill.analyze() self.elements[name] = np def draw_triangles(self, points = None, color = None, name = None, parent = None): vdata = GeomVertexData('trig', GeomVertexFormat.getV3c4(), Geom.UHStatic) vwriter = GeomVertexWriter(vdata, 'vertex') cwriter = GeomVertexWriter(vdata, 'color') for i in points : vwriter.addData3f(i[0], i[1], i[2]) cwriter.addData4f(color[0], color[1], color[2], color[3]) geom = Geom(vdata) prim = GeomTriangles(Geom.UHStatic) for i in range(len(points)) : prim.addVertex(i) prim.closePrimitive() geom.addPrimitive(prim) geomNode = GeomNode('trig') geomNode.addGeom(geom) np = NodePath(geomNode) if parent == None : render.attachNewNode(np.node()) else : self.get_parent(parent).attachNewNode(np.node()) np.setTransparency(TransparencyAttrib.MAlpha) #fill=self.screen.attachNewNode(geomNode) #fill.analyze() self.elements[name] = np return np def draw_trianglefan(self, ps, color, name, parent = None): vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic) vwriter = GeomVertexWriter(vdata, 'vertex') for i in ps : vwriter.addData3f(i[0], i[1], i[2]) prim = GeomTrifans(Geom.UHStatic) for i in range(len(ps)) : prim.addVertex(i) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) geomNode = GeomNode('trig') geomNode.addGeom(geom) np = NodePath(geomNode) if parent == None : render.attachNewNode(np.node()) else : parent.attachNewNode(np.node()) #fill=self.screen.attachNewNode(geomNode) #fill.analyze() self.elements[name] = np def draw_polygon2d(self,ps,color,name): vdata = GeomVertexData('trig', GeomVertexFormat.getV3(), Geom.UHStatic) vwriter = GeomVertexWriter(vdata, 'vertex') trig = Triangulator() for i in ps : vi = trig.addVertex(i[0], i[1]) vwriter.addData3f(i[0], 0, i[1]) trig.addPolygonVertex(vi) trig.triangulate() prim = GeomTriangles(Geom.UHStatic) for i in range(trig.getNumTriangles()): prim.addVertices(trig.getTriangleV0(i), trig.getTriangleV1(i), trig.getTriangleV2(i)) prim.closePrimitive() geom = Geom(vdata) geom.addPrimitive(prim) geomNode = GeomNode('trig') geomNode.addGeom(geom) np = NodePath(geomNode) np.reparentTo(self.screen) #fill=self.screen.attachNewNode(geomNode) #fill.analyze() self.elements[name] = np def draw_image2d(self, **kw): ''' tex = loader.loadTexture(texname) vdata = GeomVertexData('trig', GeomVertexFormat.getV3t2(), Geom.UHStatic) vwriter = GeomVertexWriter(vdata, 'vertex') twriter = GeomVertexWriter(vdata, 'texcoord') vwriter.addData3f(i[0], 0, i[1]) vwriter.addData3f(i[0], 0, i[1]) twriter.addData2f(0, 0) twriter.addData2f(0, 1) twriter.addData2f(1, 1) twriter.addData2f(1, 0) geom = Geom(vdata) tris = GeomTristrips(Geom.UHStatic) tris.addVertex(0) tris.addVertex(1) tris.addVertex(3) tris.addVertex(2) tris.closePrimitive() geom.addPrimitive(tris) node = GeomNode(name) node.addGeom(geom) np = self.screen.attachNewNode(node) np.setTexture(tex) np.getTexture().setMinfilter(Texture.FTLinearMipmapLinear) self.elements[name] = node ''' pos = kw.get('pos', (0, 0)) size = kw.get('size', None) texname = kw.get('texname', None) scaleX = kw.get('scaleX', 1) scaleY = kw.get('scaleY', 1) parent = self.get_parent( kw.get('parent', 'gui_surface') ) name = kw.get('name', self.generate_name()) tex = Texture() if texname <> None : if texname in textures.keys() : tex = textures[texname] else : tex = loader.loadTexture(texname) cm = CardMaker('card') xframe = tex.getXSize() if tex.getOrigFileXSize() <> 0 : xframe = tex.getOrigFileXSize() yframe = tex.getYSize() if tex.getOrigFileYSize() <> 0 : yframe = tex.getOrigFileYSize() if size == None : size = (tex.getXSize(), tex.getYSize()) cm.setFrame(0,size[0]*scaleX,0,size[1]*scaleY) card = None if parent == None : card = self.screen.attachNewNode(cm.generate()) else : card = parent.attachNewNode(cm.generate()) if texname <> None : card.setTexture(tex) card.setDepthTest(False) card.setPos(pos[0],0,pos[1]) #card.setHpr(0,-90,0) self.elements[name] = card return card def create_image2d(self, **kwargs): pos = kwargs.get('pos', (0, 0)) size = kwargs.get('size', None) texname = kwargs.get('texname', None) UVmap = kwargs.get('UVmap', 0) name = kwargs.get('name', self.generate_name()) rotate = 0 for i in kwargs.keys() : if i == 'rotate' : rotate = kwargs['rotate'] cm = CardMaker('card') tex = None if texname <> None : tex = loader.loadTexture(texname) if size == None and texname <> None : size = (tex.getOrigFileXSize(), tex.getOrigFileYSize()) cm.setFrame(-float(size[0])/2,float(size[0])/2,-float(size[1])/2,float(size[1])/2) if tex <> None and UVmap : fU, fV = 1, 1 if UVmap == 3 or UVmap == 1: fU = float(size[0])/tex.getOrigFileXSize() if UVmap == 3 or UVmap == 2: fV = float(size[1])/tex.getOrigFileYSize() cm.setUvRange((0, 0),(fU, fV)) card = NodePath(cm.generate()) if texname <> None : card.setTexture(tex) card.setDepthTest(False) card.setPos(pos[0]+float(size[0])/2,0,pos[1]+float(size[1])/2) card.setHpr(0,0,rotate) card.setTransparency(TransparencyAttrib.MAlpha) return card def create_model_xt(self, **kw):#pos, model, texture, size, name = None): pos = kw.get('pos', (0, 0, 0)) model = kw.get('fname', None) texture = kw.get('texname', None) size = kw.get('size', (1, 1)) name = kw.get('name', self.generate_name()) if self.check_name(name) : #print 'create_model_xt name duplicated', name return None model = self.game_directory + Filename.fromOsSpecific('\\' + model).getFullpath() a = loader.loadModel(model) texture = self.game_directory + Filename.fromOsSpecific('\\' + texture).getFullpath() a.setTexture(loader.loadTexture(texture)) a.reparentTo(render) cmin, cmax = a.getTightBounds() smax = 0 sx = size[0]/(cmax[0] - cmin[0]) sy = size[1]/(cmax[1] - cmin[1]) if sx > sy : smax = sx else : smax = sy a.setScale(smax) shiftx = ( (cmax[0] + cmin[0])/2 ) * smax shifty = ( (cmax[1] + cmin[1])/2 ) * smax a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2]) #m.flattenLight() #a.analyze() if name == None : name = self.generate_name() self.elements[name] = a return a def create_model_egg(self, pos, model, texture, size, name = None): model = self.game_directory + Filename.fromOsSpecific('\\' + model).getFullpath() a = loader.loadModel(model) a.reparentTo(render) cmin, cmax = a.getTightBounds() smax = 0 sx = size[0]/(cmax[0] - cmin[0]) sy = size[1]/(cmax[1] - cmin[1]) if sx > sy : smax = sx else : smax = sy a.setScale(smax) shiftx = ( (cmax[0] + cmin[0])/2 ) * smax shifty = ( (cmax[1] + cmin[1])/2 ) * smax a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2]) #m.flattenLight() #a.analyze() if name == None : name = self.generate_name() self.elements[name] = a print '!!!' return name def create_actor_egg(self, **kw): model = self.game_directory + Filename.fromOsSpecific('\\' + kw['model']).getFullpath() m = loader.loadModel(model) a = Actor(m, kw['anims']) a.reparentTo(render) cmin, cmax = a.getTightBounds() smax = 0 size = kw['size'] sx = size[0]/(cmax[0] - cmin[0]) sy = size[1]/(cmax[1] - cmin[1]) if sx > sy : smax = sx else : smax = sy a.setScale(smax) shiftx = ( (cmax[0] + cmin[0])/2 ) * smax shifty = ( (cmax[1] + cmin[1])/2 ) * smax pos = kw['pos'] a.setPos(pos[0] - shiftx,pos[1] - shifty,pos[2]) #m.flattenLight() #a.analyze() name = kw.get('name', None) if name == None : name = self.generate_name() self.elements[name] = a return name def map_to_scr(self, a): #print 'mts', self.map_pos, a, [ (a[0] - self.map_pos[0])*self.map_zoom, (a[1] - self.map_pos[1])*self.map_zoom ], self.width, self.height return [ (a[0] - self.map_pos[0])*self.map_zoom, (a[1] - self.map_pos[1])*self.map_zoom ] def scr_to_map(self, a): #a is (-1,-1) to (1,1) pos3d = Point3() nearPoint = Point3() farPoint = Point3() self.p3d.camLens.extrude(a, nearPoint, farPoint) self.plane.intersectsLine(pos3d, render.getRelativePoint(self.p3d.camera, nearPoint), render.getRelativePoint(self.p3d.camera, farPoint)) return pos3d[0],pos3d[1] def set_map_pos(self, posx, posy): self.p3d.camera.setX(posx) self.p3d.camera.setY(posy) #self.gr.p3d.camera.lookAt(250,0,550) self.map_pos = (posx, posy) def set_map_zoom(self, zoom): self.p3d.camera.setZ( zoom ) def zoom_in(self): self.p3d.camera.setZ( self.p3d.camera.getZ()*0.9 ) self.minimap.update_pos(True) if self.p3d.camera.getZ() < 200 : self.paths_all_node.show() def zoom_out(self): self.p3d.camera.setZ( self.p3d.camera.getZ()*1.1 ) self.minimap.update_pos(True) if self.p3d.camera.getZ() > 200 : self.paths_all_node.hide() def generate_name(self): name = str(RANDINT(0,9)) while name in self.elements.keys() : name += str(RANDINT(0,9)) return name def delete_el(self, name): if name in self.elements.keys() : self.elements[name].removeNode() self.elements.pop(name) def delete_el_mask(self,mask): for i in self.elements.keys() : if mask in i : self.delete_el(i) def get_num_nodes_rec(self, a): x = 0 l = len(a.getChildren()) if l == 0 : return 1 else : for c in a.getChildren() : x += self.get_num_nodes_rec(c) return x def get_num_nodes(self): a = self.get_num_nodes_rec(render) b = self.get_num_nodes_rec(render2d) c = self.get_num_nodes_rec(aspect2d) print 'render', a, 'render2d', b, 'aspect2d', c def check_name(self, name): if name in self.elements.keys() : return True else : return False def keyboard(self, st, keyname): if st == 0 : self.game_pipe.send(('key_down', keyname)) elif st == 1 : self.game_pipe.send(('key_up', keyname)) elif st == 2 : self.game_pipe.send(('key_rep', keyname))
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)
class LoadingScreen(DirectObject.DirectObject): def __init__(self, parent): DirectObject.DirectObject.__init__(self) self.parent = parent self.state = False self.model = None self.wheel = None self.snapshot = None self.snapshotFrame = None self.snapshotFrameBasic = None self.currentTime = 0 self.lastUpdateTime = globalClock.getRealTime() self.locationLabel = None self.locationText = None self.hintLabel = None self.hintText = None self.adImage = None self.allowLiveFlatten = ConfigVariableBool('allow-live-flatten') self.title_art = [] self.tempVolume = [] def startLoading(self): pass def beginStep(self, stageName, amt=0, percent=0): self.update() def endStep(self, stageName): self.update() def tick(self): self.update() def destroy(self): 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() taskMgr.remove('updateLoadingScreen') 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 or base.config.GetBool('no-loading-screen', 0): return None self.startLoading() render.hide() self.state = True gsg = base.win.getGsg() if gsg: gsg.setIncompleteRender(False) base.setTaskChainNetNonthreaded() self.allowLiveFlatten.setValue(1) if self.parent and base.cr.isPaid( ) == OTPGlobals.AccessVelvetRope and base.config.GetBool( 'loading-screen-interstitial', 0): self.model = loader.loadModel( 'models/gui/loading_screen_interstitial') if self.model is not None: loadimage = self.model.find('**/loadimage') if loadimage is not None: loadimage.hide() else: self.model = loader.loadModel('models/gui/loading_screen') self.locationLabel = DirectLabel( parent=aspect2dp, 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.52000000000000002), textMayChange=1) self.hintLabel = DirectLabel( parent=aspect2dp, 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.80000000000000004), text_wordwrap=30, textMayChange=1) self.wheel = self.model.find('**/red_wheel') title_bg = self.model.find('**/title_bg') title_frame = self.model.find('**/title_frame') if self.parent and base.cr.isPaid( ) == OTPGlobals.AccessVelvetRope and base.config.GetBool( 'loading-screen-interstitial', 0): self.hintLabel.setPos(0.68999999999999995, 0, -0.63) self.hintLabel['text_wordwrap'] = 12 self.locationLabel.setPos(-0.11, 0.0, -0.65000000000000002) root = self.model.find('**/loading_screen_top') timer = self.model.find('**/timer') gear = self.model.find('**/gear') shell = self.model.find('**/shell') frame_little = self.model.find('**/frame_little') self.wheel.reparentTo(timer, 0) gear.reparentTo(timer, 1) shell.reparentTo(timer, 2) title_bg.reparentTo(root) title_frame.reparentTo(root) self.snapshotFrameBasic = DirectFrame( parent=aspect2dp, relief=DGG.FLAT, frameColor=(0.0, 0.0, 0.0, 1.0), frameSize=(-4.9500000000000002, -2.5, -1.1000000000000001, -2.6000000000000001)) self.snapshotFrameBasic.reparentTo(root) frame_little.reparentTo(root) self.title_art.append(title_bg) self.title_art.append(title_frame) self.hideTitleFrame() if not waitForLocation: if self.snapshot is None: screenshot = random.choice(tutorialShots_MoveAim) self._LoadingScreen__setLoadingArt(screenshot) if self.snapshot: self.snapshot.show() elif self.snapshot: self.snapshot.show() if self.parent and self.snapshot and base.cr.isPaid( ) == OTPGlobals.AccessVelvetRope and base.config.GetBool( 'loading-screen-interstitial', 0): root = self.model.find('**/loading_screen_top') frame_little = self.model.find('**/frame_little') self.snapshot.reparentTo(root, 0) frame_little.reparentTo(root, 1) self.snapshotFrame = DirectFrame(parent=aspect2dp, relief=DGG.FLAT, frameColor=(0.0, 0.0, 0.0, 1.0), frameSize=(-2.0, 2.0, 2.0, -2.0)) self.snapshotFrame.setBin('fixed', 0) self.model.reparentTo(aspect2dp, NO_FADE_SORT_INDEX) self.locationLabel.reparentTo(aspect2dp, NO_FADE_SORT_INDEX) self.hintLabel.reparentTo(aspect2dp, NO_FADE_SORT_INDEX) if self.parent and base.cr.isPaid( ) == OTPGlobals.AccessVelvetRope and base.config.GetBool( 'loading-screen-interstitial', 0): self.model.setScale(0.22, 0.22, 0.22) self.model.setPos(0.0, 0.0, -0.29999999999999999) else: self.model.setScale(0.25, 0.25, 0.25) self.model.setPos(0.0, 0.0, -0.14999999999999999) if self.locationText and len(self.locationText): self._LoadingScreen__setLocationText(self.locationText) if self.hintText is not None: if len(self.hintText): self._LoadingScreen__setHintText(self.hintText) if self.parent and base.cr.isPaid( ) == OTPGlobals.AccessVelvetRope and base.config.GetBool( 'want-ad-reporting', 0) and base.config.GetBool( 'loading-screen-interstitial', 0): self._LoadingScreen__setAdArt() 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') def showHint(self, destId=None, ocean=False): if base.config.GetBool('no-loading-screen', 0): 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._LoadingScreen__setHintText(hint) def update(self, task=None): if not self.state: 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 self.wheel.setR(-(self.currentTime)) base.graphicsEngine.renderFrame() return Task.cont def hide(self): if not self.state: return None render.show() base.graphicsEngine.renderFrame() self.state = False self.currentTime = 0 self.locationText = None self.hintText = None gsg = base.win.getGsg() if gsg: gsg.setIncompleteRender(True) render.prepareScene(gsg) render2d.prepareScene(gsg) for part in (self.model, self.snapshot): if part: tex = part.findTexture('*') if tex: tex.releaseAll() part.removeNode() self.model = None self.snapshot = None if self.adImage: self.adImage = None if self.snapshotFrame: self.snapshotFrame.destroy() if self.locationLabel: self.locationLabel.destroy() if self.hintLabel: self.hintLabel.destroy() 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): 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 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] """ elif len(screenshot) > 1: screenshot = random.choice(screenshot) else: screenshot = screenshot[0] """ self._LoadingScreen__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._LoadingScreen__setLocationText(targetName) def _LoadingScreen__setLoadingArt(self, screenshot): if self.snapshot: 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) self.snapshot = loader.loadModel(screenshot) if self.snapshot: if self.parent and base.cr.isPaid( ) == OTPGlobals.AccessVelvetRope and base.config.GetBool( 'loading-screen-interstitial', 0): self.snapshot.setScale(2.3500000000000001, 1.0, 1.3) self.snapshot.setPos(-3.7400000000000002, 0, -1.8300000000000001) if self.model is not None: root = self.model.find('**/loading_screen_top') frame_little = self.model.find('**/frame_little') self.snapshot.reparentTo(root, 0) frame_little.reparentTo(root, 1) else: self.snapshot.reparentTo(aspect2dp, NO_FADE_SORT_INDEX) self.snapshot.setScale(2.1499999999999999, 1, 1.2) self.snapshot.setPos(0.0, 0.0, 0.089999999999999997) self.snapshot.setBin('fixed', 1) if not self._LoadingScreen__isVisible(): self.snapshot.hide() def _LoadingScreen__setLocationText(self, locationText): self.locationText = locationText if self._LoadingScreen__isVisible(): self.locationLabel['text'] = locationText self.locationLabel.show() self.showTitleFrame() launcher.setValue('gameLocation', self.locationText) def _LoadingScreen__setHintText(self, hintText): self.hintText = hintText if self._LoadingScreen__isVisible(): self.hintLabel['text'] = hintText self.hintLabel.show() def _LoadingScreen__isVisible(self): return self.state def scheduleHide(self, function): base.cr.queueAllInterestsCompleteEvent() self.acceptOnce(function, self.hide) def _LoadingScreen__setAdArt(self): 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)