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)
