def __init__(self, width=1, depth=1, height=1, thickness=1.0, origin=Point3(0, 0, 0)): def __Get3dPoint(pt, origin, axis): p = Point3(pt.x, pt.y, 0) - origin return RotatePoint3(p, Vec3(0, 0, 1), axis) # Create line segments self.ls = LineSegs() self.ls.setThickness(thickness) # axes = [Vec3(1, 0, 0), Vec3(0, 1, 0), Vec3(0, 0, 1), Vec3(1, 0, 0), Vec3(0, 1, 0), Vec3(0, 0, 1)] # origins = [origin, origin, origin, origin + Point3(0, 0, -1), origin + Point3(0, 0, -1), origin + Point3(0, 0, 1)] axes = [Vec3(1, 0, 0), Vec3(0, 1, 0), Vec3(-1, 0, 0), Vec3(0, -1, 0)] origins = [origin, origin, origin, origin] for m in range(len(axes)): # Get the points for square, append the first one to the end to # complete the square pts = GetPointsForSquare2(width, height) pts.append(pts[0]) for i in range(len(pts) - 1): # Get the distance a third of the way along the edge dist = (pts[i + 1] - pts[i]) / 3 # Draw one square self.ls.moveTo(__Get3dPoint(pts[i], origins[m], axes[m])) self.ls.drawTo(__Get3dPoint(pts[i] + dist, origins[m], axes[m])) self.ls.moveTo(__Get3dPoint(pts[i] + dist + dist, origins[m], axes[m])) self.ls.drawTo(__Get3dPoint(pts[i + 1], origins[m], axes[m])) # Init the node path, wrapping the lines node = self.ls.create() NodePath.__init__(self, node)
def __init__(self, moveTrack, tOffset, posScale = 1.0): NodePath.__init__(self) self.assign(hidden.attachNewNode(base.localAvatar.uniqueName('ring'))) self.setMoveTrack(moveTrack) self.setTOffset(tOffset) self.setPosScale(posScale) self.setT(0.0)
def abandon(self):# and all descendents c = NodePath(self).find('-PandaNode') if c: for child in c.getChildren(): child.node().getPythonTag('extras').abandon() # abandon descendents #print 'abandoning-- ', self self.setPythonTag("extras", 'done') # abandon self
def __init__(self, phone, doneEvent=None): NodePath.__init__(self, aspect2d.attachNewNode('CatalogGUI')) DirectObject.__init__(self) CatalogGlobals.CatalogNodePath.find('**/CATALOG_GUI_BKGD').copyTo(self) self.setScale(CatalogGlobals.CatalogBKGDScale) self.phone = phone self.doneEvent = doneEvent self.arrowButtons = {} self.createArrowButtons() self.currentTab = None self.tabButtons = {} self.createTabButtons() self.radioButtons = [] # self.createRadioButtons() self.activePage = 0 self.gifting = -1 guiItems = loader.loadModel('phase_5.5/models/gui/catalog_gui') hangupGui = guiItems.find('**/hangup') hangupRolloverGui = guiItems.find('**/hangup_rollover') self.hangup = DirectButton(self, relief=None, pos=(2.28, 0, -1.3), image=[hangupGui, hangupRolloverGui, hangupRolloverGui, hangupGui], text=['', TTLocalizer.CatalogHangUp, TTLocalizer.CatalogHangUp], text_fg=Vec4(1), text_scale=0.07, text_pos=(0.0, 0.14), command=self.hangUp) guiItems.removeNode()
def __init__(self, game, id, x, y): NodePath.__init__(self, 'dropNode%s' % id) self.game = game self.id = id self.reparentTo(hidden) self.setPos(x, y, 0) shadow = loader.loadModel('phase_3/models/props/square_drop_shadow') shadow.setZ(0.2) shadow.setBin('ground', 10) shadow.setColor(1, 1, 1, 1) shadow.reparentTo(self) self.shadow = shadow drop = CogdoUtil.loadMazeModel('cabinetSmFalling') roll = random.randint(-15, 15) drop.setHpr(0, 0, roll) drop.setZ(Globals.DropHeight) self.collTube = CollisionTube(0, 0, 0, 0, 0, 4, Globals.DropCollisionRadius) self.collTube.setTangible(0) name = Globals.DropCollisionName self.collNode = CollisionNode(name) self.collNode.addSolid(self.collTube) self.collNodePath = drop.attachNewNode(self.collNode) self.collNodePath.hide() self.collNodePath.setTag('isFalling', str('True')) drop.reparentTo(self) self.drop = drop self._dropSfx = base.cogdoGameAudioMgr.createSfxIval('drop', volume=0.6)
class BigWall(StaticObject): def __init__(self, game, width=200.0, thickness=4.0, height=10): self.game = game self.collGeom = OdeBoxGeom( self.game.physicsSpace, width, thickness, height) #self.collGeom.setBody(self.body) self.collGeom.setCategoryBits( BitMask32(0x000000ff) )#ffffffff) ) self.collGeom.setCollideBits( BitMask32(0x000000ff) ) self.visualNode = NodePath('Visual node') self.visualNode.reparentTo(render) model = loader.loadModel('BigWall.egg') model.setScale(width/50.0, thickness/4.0, height) model.reparentTo(self.visualNode) model.setZ(266) # tex = loader.loadTexture('seina.jpg') # model.setTexture(tex, 1) def osuminen(self, ship1): if OdeUtil.collide(ship1.collGeom, self.collGeom): print "sdfgfdhgdfhxfhdhghcfh" print "ship1 xdfhgxdgxdgfbcdll!!"
def onEnter(menuRootID, itm, pos): taskMgr.remove(menuRootID+'leaver') # preempt possible pending onLeave()'s me = itm.getPythonTag("extras") me.menuRoot.clickBlock = True sibList=itm.getParent(0) for x in range(sibList.getNumChildren()):# hide sibling's kids bro = sibList.getChild(x) NodePath(bro).setBin("fixed", 11) kind = bro.getPythonTag("extras").item['kind'] if kind in ('parent', 'vertical', 'horizontal', 'titleBar', 'close') and bro.getNumChildren()>0: NodePath(bro.getChild(0)).hide() if bro.getState()!=DORMANT: bro.setState(SUBDUED) if itm.getState()!=DORMANT: itm.setState(HOVER) NodePath(itm).setBin("fixed", 50) if itm.getNumChildren(): # show children cdrn=itm.getChild(0) np = NodePath(cdrn) np.show() for x in range(cdrn.getNumChildren()): #show HOVERed's children c=cdrn.getChild(x) ckind = c.getPythonTag("extras").item['kind'] if ckind =='parent': # but not their children NodePath(c.getChild(0)).hide() if c.getState()!=DORMANT: c.setState(READY) while sibList.getName() != 'root': #Hilite ancestors p=sibList.getParent(0) NodePath(p).show() p.setState(HOVER) sibList=p.getParent(0)
def __init__(self, parserClass, mainClass, mapLoaderClass, modelLoaderClass): self.switchState = False # self.t = Timer() self.keyMap = {"left": 0, "right": 0, "forward": 0, "backward": 0} self.ralph = Actor( "data/models/units/ralph/ralph", {"run": "data/models/units/ralph/ralph-run", "walk": "data/models/units/ralph/ralph-walk"}, ) self.ralph.reparentTo(render) # self.ralph.setPos(42, 30, 0) self.ralph.setPos(6, 10, 0) self.ralph.setScale(0.1) self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", 1]) self.accept("arrow_left-up", self.setKey, ["left", 0]) self.accept("arrow_right", self.setKey, ["right", 1]) self.accept("arrow_right-up", self.setKey, ["right", 0]) self.accept("arrow_up", self.setKey, ["forward", 1]) self.accept("arrow_up-up", self.setKey, ["forward", 0]) self.accept("arrow_down", self.setKey, ["backward", 1]) self.accept("arrow_down-up", self.setKey, ["backward", 0]) self.isMoving = False self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 1000) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode("ralphRay") self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) # self.ralphGroundCol.show() base.cam.reparentTo(self.ralph) base.cam.setPos(0, 9, 7) self.floater2 = NodePath(PandaNode("floater2")) self.floater2.reparentTo(self.ralph) self.floater2.setZ(self.floater2.getZ() + 6) base.cam.lookAt(self.floater2) # Uncomment this line to see the collision rays # self.ralphGroundColNp.show() # self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring # self.cTrav.showCollisions(render) self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) taskMgr.add(self.move, "movingTask", extraArgs=[mainClass, parserClass, mapLoaderClass, modelLoaderClass])
def loaderPhaseChecker(self, path, loaderOptions): if 'audio/' in path: return 1 file = Filename(path) if not file.getExtension(): file.setExtension('bam') mp = getModelPath() path = mp.findFile(file).cStr() if not path: return match = re.match('.*phase_([^/]+)/', path) if not match: if 'dmodels' in path: return else: self.errorAccumulatorBuffer += 'file not in phase (%s, %s)\n' % (file, path) return basePhase = float(match.groups()[0]) if not launcher.getPhaseComplete(basePhase): self.errorAccumulatorBuffer += 'phase is not loaded for this model %s\n' % path model = loader.loader.loadSync(Filename(path), loaderOptions) if model: model = NodePath(model) for tex in model.findAllTextures(): texPath = tex.getFullpath().cStr() match = re.match('.*phase_([^/]+)/', texPath) if match: texPhase = float(match.groups()[0]) if texPhase > basePhase: self.errorAccumulatorBuffer += 'texture phase is higher than the models (%s, %s)\n' % (path, texPath)
def loadAndBuildLevel(self, safezoneId): levelNode = NodePath('level') frameModel = CogdoUtil.loadFlyingModel('level') startPlatformModel = CogdoUtil.loadFlyingModel('levelStart') endPlatformModel = CogdoUtil.loadFlyingModel('levelEnd') for fan in frameModel.findAllMatches('**/*wallFan'): fan.flattenStrong() frameModel.find('**/fogOpaque').setBin('background', 1) frameModel.find('**/ceiling').setBin('background', 2) frameModel.find('**/fogTranslucent_bm').setBin('fixed', 1) frameModel.find('**/wallR').setBin('opaque', 2) frameModel.find('**/wallL').setBin('opaque', 2) frameModel.find('**/fogTranslucent_top').setBin('fixed', 2) frameModel.getChildren().reparentTo(levelNode) levelNode.hide() self._level = CogdoFlyingLevel(self.parent, levelNode, startPlatformModel, endPlatformModel, self.quadLengthUnits, self.quadVisibiltyAhead, self.quadVisibiltyBehind) if Globals.Dev.WantTempLevel: quads = Globals.Dev.DevQuadsOrder else: levelInfo = Globals.Level.DifficultyOrder[safezoneId] quads = [] for difficulty in levelInfo: quadList = Globals.Level.QuadsByDifficulty[difficulty] quads.append(quadList[self._rng.randint(0, len(quadList) - 1)]) for i in quads: filePath = CogdoUtil.getModelPath('quadrant%i' % i, 'flying') quadModel = loader.loadModel(filePath) for np in quadModel.findAllMatches('**/*lightCone*'): CogdoUtil.initializeLightCone(np, 'fixed', 3) self._level.appendQuadrant(quadModel) self._level.ready()
def map_populate(self,task): self.init_collisions() for p in range(len(self.provinces)): city = loader.loadModel("models/house2.x") city.reparentTo(render) city.setName(self.provinces[p+1][0]) city.setScale(2, 2, 2) x = float(self.provinces[p+1][2]*self.map_scale)-(self.map_width/2) y = self.map_height-float(self.provinces[p+1][3]*self.map_scale)-(self.map_height/2) city.setPos(x, y, 1.0) city_col = city.attachNewNode(CollisionNode("CityCNode%d"%p)) city_col.setScale((3,3,3)) city_col.node().addSolid(CollisionSphere(0,0,0,1)) city_col.setTag("prov","city") city.setTag("id",str(p+1)) for p in range(len(self.paths)): path_split = string.replace(self.paths[p],"-"," ") path_split = string.split(path_split) prov_a = int(path_split[0]) prov_b = int(path_split[1]) line = LineSegs() line.setColor(1, 0, 0, 1) line.setThickness(5) line.moveTo(self.provinces[prov_a][2]-600, -(self.provinces[prov_a][3])+350, 2) line.drawTo(self.provinces[prov_b][2]-600, -(self.provinces[prov_b][3])+350, 2) node = line.create() node_path = NodePath(node) node_path.reparentTo(render) print "line drawn",self.provinces[prov_a][2],self.provinces[prov_a][3] for a in range(len(self.armies)): self.army_create(a+1,self.armies[a+1][2]) self.load_state = "Done!" task.done
def __init__(self, width=1, depth=1, height=1, origin=Point3(0, 0, 0)): # Create vetex data format gvf = GeomVertexFormat.getV3n3() gvd = GeomVertexData("vertexData", gvf, Geom.UHStatic) # Create vetex writers for each type of data we are going to store gvwV = GeomVertexWriter(gvd, "vertex") gvwN = GeomVertexWriter(gvd, "normal") # Write out all points for p in GetPointsForBox(width, depth, height): gvwV.addData3f(Point3(p) - origin) # Write out all the normals for n in ((-1, 0, 0), (1, 0, 0), (0, -1, 0), (0, 1, 0), (0, 0, -1), (0, 0, 1)): for i in range(4): gvwN.addData3f(n) geom = Geom(gvd) for i in range(0, gvwV.getWriteRow(), 4): # Create and add both triangles geom.addPrimitive(GetGeomTriangle(i, i + 1, i + 2)) geom.addPrimitive(GetGeomTriangle(i, i + 2, i + 3)) # Init the node path, wrapping the box geomNode = GeomNode("box") geomNode.addGeom(geom) NodePath.__init__(self, geomNode)
def __init__(self, *args, **kwargs): NodePath.__init__(self, *args, **kwargs) DirectObject.__init__(self) self.scale_signal = Signal() self.reset()
def __init__(self, name, parent, allWoodSquaresGeom, selectedOutlineGeom, command, location, **kw): optiondefs = () self.defineoptions(kw, optiondefs) DirectButton.__init__(self, parent) self.initialiseoptions(RepairGridPiece) FSM.FSM.__init__(self, 'RepairGridPiece_%sFSM' % name) self.name = name self.allWoodSquaresGeom = allWoodSquaresGeom self.selectedOutlineGeom = selectedOutlineGeom self.command = command self.location = location self._initVars() self._initGUI() self._initIntervals() self.accept(self.guiItem.getEnterEvent(), self.onMouseEnter) self.accept(self.guiItem.getExitEvent(), self.onMouseExit) self.bind(DGG.B1PRESS, self.onMouseDown) self.bind(DGG.B1RELEASE, self.onMouseUp) self.bind(DGG.B2PRESS, self.onMouseUp) self.bind(DGG.B2RELEASE, self.onMouseUp) self.bind(DGG.B3PRESS, self.onMouseUp) self.bind(DGG.B3RELEASE, self.onMouseUp) self.idleGeom = NodePath('idleGeom') self.highlightedGeom = NodePath('highlightedGeom') self.haveMoved = False self.grabPoint = None self.setType(GOAL_NONE)
def restart(self): """Start or restart the plugin.""" self.draw = Draw() # Utility for drawing 2D lines and shapes in 3-space path = Path([Vec2(40,40),Vec2(40,-40),Vec2(-40,40),Vec2(-40,-40)]) for vehicle in self.vehicles[:3]: vehicle._pos = SteerVec((random.random()-0.5)*100,(random.random()-0.5)*100) vehicle._velocity = SteerVec((random.random()-0.5)*2,(random.random()-0.5)*2) vehicle.followPath(path,loop=True) c=(.6,.6,.6,.3) t=1 z=1.5 self.draw.drawLine(Vec3(path[0].getX(),path[0].getY(),z),Vec3(path[1].getX(),path[1].getY(),z),color=c,thickness=t) self.draw.drawLine(Vec3(path[1].getX(),path[1].getY(),z),Vec3(path[2].getX(),path[2].getY(),z),color=c,thickness=t) self.draw.drawLine(Vec3(path[2].getX(),path[2].getY(),z),Vec3(path[3].getX(),path[3].getY(),z),color=c,thickness=t) self.draw.drawLine(Vec3(path[3].getX(),path[3].getY(),z),Vec3(path[0].getX(),path[0].getY(),z),color=c,thickness=t) path = Path([Vec2(-40,-40),Vec2(40,-40),Vec2(-40,40),Vec2(40,40)]) for vehicle in self.vehicles[3:]: vehicle._pos = SteerVec((random.random()-0.5)*100,(random.random()-0.5)*100) vehicle._velocity = SteerVec((random.random()-0.5)*2,(random.random()-0.5)*2) vehicle.followPath(path,loop=True) self.draw.drawLine(Vec3(path[0].getX(),path[0].getY(),z),Vec3(path[1].getX(),path[1].getY(),z),color=c,thickness=t) self.draw.drawLine(Vec3(path[1].getX(),path[1].getY(),z),Vec3(path[2].getX(),path[2].getY(),z),color=c,thickness=t) self.draw.drawLine(Vec3(path[2].getX(),path[2].getY(),z),Vec3(path[3].getX(),path[3].getY(),z),color=c,thickness=t) self.draw.drawLine(Vec3(path[3].getX(),path[3].getY(),z),Vec3(path[0].getX(),path[0].getY(),z),color=c,thickness=t) for vehicle in self.vehicles: vehicle.avoidObstacles = True vehicle.avoidVehicles = True vehicle.maxforce = 0.1 vehicle.maxspeed = 0.5 + (random.random()/2) node = self.draw.create() np = NodePath(node) np.reparentTo(render)
def __init__(self, fishManager, myData, index, trophy = 0): NodePath.__init__(self, '%s_%d' % (myData['name'], index)) self.trophy = trophy self.myData = myData if not self.trophy: self.fishManager = fishManager self.index = index self.fsm = FishFSM(self) self.weight = random.randint(self.myData['weightRange'][0], self.myData['weightRange'][1]) else: self.weight = trophy self.adjustedScale = (self.myData['scaleRange'][1] - self.myData['scaleRange'][0]) * (self.weight - self.myData['weightRange'][0]) / (self.myData['weightRange'][1] - self.myData['weightRange'][0]) + self.myData['scaleRange'][0] self.initActor() if not self.trophy: self.initVariables() self.initFishStatusIcon() if FishingGlobals.wantDebugCollisionVisuals: self.initCollisions() self.avoidingFish = False self.biteBubbleEffect = None self.idleBubbleEffect = None self.fightBubbleEffect = None self.behaviorNameToFunction = { 'straight': self.performStraightBehavior, 'sineStraight': self.performSineStraightBehavior, 'erratic': self.performErraticBehavior } self.sineDtAccumulator = 0.0 self.erraticDtAccumulator = 0.0 self.myZ = 0.0 if not self.trophy: self.setLightOff()
def cleanup(self): for page in self.catalogItemPages: page.cleanup() self.tabButton.destroy() NodePath.removeNode(self)
def draw(self): # Draw attack radius attackRadLine = LineSegs() attackRadLine.setThickness(1) attackRadLine.setColor(self._color) attackRadLine.moveTo(self.attackRad, 0, 0) for i in range(self._EDGES + 1): newX = (self.attackRad * math.cos((2*math.pi/self._EDGES)*i)) newY = (self.attackRad * math.sin((2*math.pi/self._EDGES)*i)) attackRadLine.drawTo(newX, newY, 0) attackRadGeom = attackRadLine.create() self._attackRadCircleNP = NodePath(attackRadGeom) self._attackRadCircleNP.reparentTo(self._np) # Draw foot circle self._footCircle.setThickness(1) self._footCircle.setColor(self._color) self._footCircle.moveTo(self.footRad, 0, 0) for i in range(self._EDGES): newX = (self.footRad * math.cos((2*math.pi/self._EDGES)*i)) newY = (self.footRad * math.sin((2*math.pi/self._EDGES)*i)) self._footCircle.drawTo(newX, newY, 0) self._footCircle.drawTo(self.footRad, 0, 0) footCircleGeom = self._footCircle.create() self._footCircleNP = NodePath(footCircleGeom) self._footCircleNP.reparentTo(self._np)
def place_markers(self,nodes): for n in range(len(nodes)): town_node = NodePath("town") town = loader.loadModel("models/infantry_counter.egg") x = (nodes[n+1]["x"]-map_center[0])*amplification y = (nodes[n+1]["y"]-map_center[1])*amplification town.setPos(x,y,0) if nodes[n+1]["type"] == "city": scale = 12 elif nodes[n+1]["type"] == "town": scale = 7 elif nodes[n+1]["type"] == "village": scale = 4 town.setScale(scale,scale,scale) town.reparentTo(town_node) town_node.reparentTo(render) text_node = TextNode("town_text_node") text_node.setText(nodes[n+1]["name"]) text_node_path = town.attachNewNode(text_node) text_node_path.setPos(1,0,0) text_node_path.setHpr(0,-90,0) text_node_path.setScale(scale/2) text_node_path.setTransparency(TransparencyAttrib.MAlpha) text_node.setTextColor(0.8, 0.1, 0.1, 1) text_node.setAlign(TextNode.ALeft)
class bigWall(StaticObject): def __init__(self, game): self.game = game self.collGeom = OdeBoxGeom( self.game.physicsSpace, 50, 15, 15) #self.collGeom.setBody(self.body) self.collGeom.setCategoryBits( BitMask32(0x000000ff) )#ffffffff) ) self.collGeom.setCollideBits( BitMask32(0x000000ff) ) #remember to make wall model with "50" length... no idea 50 what, though self.visualNode = NodePath('Visual node') self.visualNode.reparentTo(render) model = loader.loadModel('BigWall.egg') model.reparentTo(self.visualNode) def osuminen(self, ship1): if OdeUtil.collide(ship1.collGeom, self.collGeom): print "sdfgfdhgdfhxfhdhghcfh" print "ship1 xdfhgxdgxdgfbcdll!!"
def draw(self): format=GeomVertexFormat.getV3n3cpt2() vdata=GeomVertexData('square', format, Geom.UHDynamic) vertex=GeomVertexWriter(vdata, 'vertex') normal=GeomVertexWriter(vdata, 'normal') color=GeomVertexWriter(vdata, 'color') circle=Geom(vdata) # Create vertices vertex.addData3f(self.pos) color.addData4f(self.color) for v in range(self._EDGES): x = self.pos.getX() + (self.size * math.cos((2*math.pi/self._EDGES)*v)) y = self.pos.getY() + (self.size * math.sin((2*math.pi/self._EDGES)*v)) z = self.pos.getZ() vertex.addData3f(x, y, z) color.addData4f(self.color) # Create triangles for t in range(self._EDGES): tri = GeomTriangles(Geom.UHDynamic) tri.addVertex(0) tri.addVertex(t+1) if (t+2) > self._EDGES: tri.addVertex(1) else: tri.addVertex(t+2) tri.closePrimitive() circle.addPrimitive(tri) gn = GeomNode('Circle') gn.addGeom(circle) np = NodePath(gn) np.setHpr(0, 90, 0) return np
def enable(self): if self._enabled: return self._toon.detachCamera() self._prevToonY = 0.0 levelBounds = self._level.getBounds() l = Globals.Camera.LevelBoundsFactor self._bounds = ( (levelBounds[0][0] * l[0], levelBounds[0][1] * l[0]), (levelBounds[1][0] * l[1], levelBounds[1][1] * l[1]), (levelBounds[2][0] * l[2], levelBounds[2][1] * l[2]), ) self._lookAtZ = self._toon.getHeight() + Globals.Camera.LookAtToonHeightOffset self._camParent = NodePath("CamParent") self._camParent.reparentTo(self._parent) self._camParent.setPos(self._toon, 0, 0, 0) self._camParent.setHpr(180, Globals.Camera.Angle, 0) self._camera.reparentTo(self._camParent) self._camera.setPos(0, Globals.Camera.Distance, 0) self._camera.lookAt(self._toon, 0, 0, self._lookAtZ) self._cameraLookAtNP = NodePath("CameraLookAt") self._cameraLookAtNP.reparentTo(self._camera.getParent()) self._cameraLookAtNP.setPosHpr(self._camera.getPos(), self._camera.getHpr()) self._levelBounds = self._level.getBounds() self._enabled = True self._frozen = False self._initCollisions()
def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_bracing_main') self.background = self.model.find('**/background') self.background.reparentTo(self) self.background.setZ(0.17499999999999999) self.gridParent = self.attachNewNode('gridParent') self.grid = [] for xpos in range(GRID_SIZE): col = [] for ypos in range(GRID_SIZE): allWoodSquaresGeom = NodePath('wood_squares') for i in range(self.model.find('**/wood_squares').getNumChildren()): self.model.find('**/wood_squares').getChild(i).copyTo(allWoodSquaresGeom) tempGeom = NodePath('tempGeom') self.model.find('**/wood_squares').getChild(0).copyTo(tempGeom) selectedOutlineGeom = NodePath('selectedOutlineGeom') self.model.find('**/selected').copyTo(selectedOutlineGeom) selectedOutlineGeom.setScale(0.90000000000000002) piece = RepairGridPiece(name = 'piece%i' % (xpos * GRID_SIZE + ypos), parent = self.gridParent, allWoodSquaresGeom = allWoodSquaresGeom, selectedOutlineGeom = selectedOutlineGeom, scale = (0.90000000000000002, 0.90000000000000002, 0.90000000000000002), pos = (-0.22 + xpos * SPACING, 0.0, -0.029999999999999999 + ypos * SPACING), command = self.onPiecePressed, location = [ xpos, ypos], clickSound = None, pressEffect = 0, geom = tempGeom, relief = None) col.append(piece) self.grid.append(col) self.createGoalPieces()
def _optimize(self): lightCones = NodePath('lightCones') for np in self._platformsRoot.findAllMatches('**/*lightCone*'): np.wrtReparentTo(lightCones) lightCones.reparentTo(self._model) node = self._model.find('**/ducts') if not node.isEmpty(): node.flattenStrong() for np in node.getChildren(): np.wrtReparentTo(self._model) node = self._model.find('**/nests') if not node.isEmpty(): for np in node.getChildren(): np.flattenStrong() np.wrtReparentTo(self._model) for np in self._model.findAllMatches('**/*LayerStack*'): np.wrtReparentTo(self._model) if not self._model.find('**/static').isEmpty(): for np in self._model.find('**/static').getChildren(): np.wrtReparentTo(self._model) self._model.flattenMedium()
def __init__(self, cr, proximityText): NodePath.__init__(self, self.__class__.__name__) DistributedInteractive.__init__(self, cr) self.holiday = "" self.interactRadius = 10 self.interactMode = 0 self.proximityText = proximityText
def initFishStaminaBar(self): self.legendaryGui = loader.loadModel('models/minigames/pir_m_gam_fsh_legendaryGui') self.iconBaseFrame = DirectFrame(relief = None, state = DGG.DISABLED, pos = (0, 0, 0), sortOrder = 30, image = self.legendaryGui.find('**/pir_t_gui_fsh_fishPortraitFrame'), image_scale = 0.17999999999999999, image_pos = (0, 0, 0)) self.iconBaseFrame.setTransparency(TransparencyAttrib.MAlpha) self.fishUINodePath = NodePath(self.iconBaseFrame) self.fishUINodePath.setPos(-0.29999999999999999, 0.0, 0.82999999999999996) self.fishUINodePath.reparentTo(hidden) self.iconCard = loader.loadModel('models/gui/treasure_gui') self.iconBaseFrame.iconImage = OnscreenImage(parent = self.iconBaseFrame, image = self.iconCard.find('**/%s*' % CollectionMap.Assets[self.myData['id']]), scale = 0.34999999999999998, hpr = (0, 0, 0), pos = (0.0, 0, 0.0)) self.fishNameLabel = TextNode('fishNameLabel') name = self.getName().split('_') self.fishNameLabel.setText(name[0]) self.fishNameLabel.setTextColor(1.0, 1.0, 1.0, 1.0) self.fishNameLabelNodePath = NodePath(self.fishNameLabel) self.fishNameLabelNodePath.setPos(0.29999999999999999, 0, 0.040000000000000001) self.fishNameLabelNodePath.setScale(0.044999999999999998) self.fishNameLabelNodePath.reparentTo(self.iconBaseFrame) self.fishStaminaBar = DirectWaitBar(parent = self.iconBaseFrame, relief = DGG.FLAT, state = DGG.DISABLED, range = 100, value = 0, sortOrder = 20, frameColor = (0, 0, 0, 1.0), pos = (0.070000000000000007, 0.0, -0.014999999999999999), hpr = (0, 0, 0), frameSize = (0, 0.71999999999999997, 0, 0.028000000000000001)) self.fishStaminaBar['value'] = self.staminaValue self.fishStaminaBar['barColor'] = FishingGlobals.fishingStaminaBarColor[int((self.staminaValue / 100.0) * (len(FishingGlobals.fishingStaminaBarColor) - 1))] self.fishStaminaValueLabel = TextNode('fishStaminaValueLabel') self.fishStaminaValueLabel.setText(str(self.staminaValue) + '//' + str(self.staminaValue)) self.fishStaminaValueLabel.setTextColor(1.0, 1.0, 1.0, 1.0) self.fishStaminaValueLabelNodePath = NodePath(self.fishStaminaValueLabel) self.fishStaminaValueLabelNodePath.setPos(0.66000000000000003, 0, -0.059999999999999998) self.fishStaminaValueLabelNodePath.setScale(0.044999999999999998) self.fishStaminaValueLabelNodePath.reparentTo(self.iconBaseFrame) self.fishStaminaBarFrame = DirectLabel(parent = self.iconBaseFrame, relief = None, state = DGG.DISABLED, frameColor = (1, 1, 1, 0.10000000000000001), pos = (0.44, 0.0, 0.0), hpr = (0, 0, 0), sortOrder = 25, image = self.legendaryGui.find('**/pir_t_gui_fsh_staminaBarForeground'), image_scale = (1.0, 0.0, 0.050000000000000003), image_pos = (0.0, 0.0, 0.0), image_hpr = (0.0, 0.0, 0.0)) self.fishStaminaBarFrame.setTransparency(TransparencyAttrib.MAlpha) self.fishStaminaBarFrame.setDepthTest(True) self.fishStaminaBarFrame.setDepthWrite(True)
def attachNewCollidableNode( self, node, bitmask=None ): if bitmask is None: bitmask = self.bitmask # attach a new node which is colliable NodePath.attachNewNode( self, node ) self.setTag('objectId', self.objectId ) self.setCollideMask( bitMaskOr(bitmask) )
def __init__(self, cogMenu, dept): NodePath.__init__(self, 'CogMenuBar-%s' % dept) self.dept = dept self.deptIndex = CogDisguiseGlobals.dept2deptIndex(self.dept) icons = loader.loadModel('phase_3/models/gui/cog_icons') self.icon = icons.find(ICON_NODES[self.deptIndex]).copyTo(self) self.icon.setColor(ICON_COLORS[self.deptIndex]) self.icon.setScale(0.07) self.icon.setX(-0.25) icons.removeNode() self.progressBar = DirectWaitBar(parent=self, relief=DirectGuiGlobals.SUNKEN, frameSize=(-1, 1, -0.15, 0.15), borderWidth=(0.02, 0.02), scale=0.20, frameColor=(DisguisePage.DeptColors[self.deptIndex][0] * 0.7, DisguisePage.DeptColors[self.deptIndex][1] * 0.7, DisguisePage.DeptColors[self.deptIndex][2] * 0.7, 1), barColor=(DisguisePage.DeptColors[self.deptIndex][0], DisguisePage.DeptColors[self.deptIndex][1], DisguisePage.DeptColors[self.deptIndex][2], 1), text='0/0 ' + TTLocalizer.RewardPanelMeritBarLabels[self.deptIndex], text_scale=TTLocalizer.RPmeritBarLabels, text_fg=(0, 0, 0, 1), text_align=TextNode.ALeft, text_pos=(-0.96, -0.05)) self.reparentTo(cogMenu)
def __init__(self, x, y, z, environment, blocks, node, geomId): self.x = x self.y = y self.z = z self.environment = environment # The environment object for the world self.blocks = blocks # The 3D array of Block objects self.geom = 0 # A dict used to hold all of the data for geometry creation self.node = node # The parent node of the geometry self.geomId = geomId # The id of the geometry wrt the parent (needed for updating the geometry) self.dirty = 0 # A flag for whether the Chunk needs updating self.wallCollisionGeom = NodePath('wallCollisionGeom') self.wallCollisionGeom.reparentTo(render) self.floorCollisionGeom = NodePath('floorCollisionGeom') self.floorCollisionGeom.reparentTo(render) self.geomGen = BlockGeometryGenerator() self.queue = Queue.Queue() self.blockTexture = loader.loadTexture('Assets/Images/Textures/blocks.png') self.lightMapTexture = loader.loadTexture('Assets/Images/Textures/lightMap.png') self.CreateVertexFormat() self.geom = ChunkOfBlocks.CreateNewGeomDict(self.blockTexture, self.lightMapTexture, self.geomVertexFormat) ChunkOfBlocks.UpdateCollisionAndGeom(self, self.wallCollisionGeom, self.floorCollisionGeom, self.geom, self.geomGen, self.environment, blocks, x, y, z) self.AddGeom()
def __init__( self, name='camera', pos=Vec3( 0, 0, 0 ), targetPos=Vec3( 0, 0, 0 ), style=CAM_DEFAULT_STYLE ): self.zoomLevel = 2 self.defaultPos = pos self.style = style # Use Panda's default camera if self.style & CAM_USE_DEFAULT: self.cam = getBase().cam #self.camNode = getBase().camNode # Otherwise create a new one else: # Create camera self.cam = NodePath( PCamera( name ) ) # Create lens lens = PerspectiveLens() lens.setAspectRatio( 800.0 / 300.0 ) self.cam.node().setLens( lens ) # Wrap the camera in this node path class NodePath.__init__( self, self.cam ) # Create camera styles if self.style & CAM_VIEWPORT_AXES: self.axes = self.Axes() self.axes.reparentTo( pixel2d ) # Create camera target self.target = self.Target( pos=targetPos ) self.Reset()
def createThrowGag(self, gag): throwGag = gag.copyTo(NodePath('gag')) return throwGag
def createSprite(self, sprite): ''' Creates a new sprite and returns a SpriteRenderInterface for controlling this sprite instance. The newly created sprite is located at (0,0) in screen coordinates its dimensions are specified by the given Sprite argument. @param sprite: A Sprite resource that describes the properties of the sprite to created. @return: A SpriteRenderInterface instance or None if it failed to create the sprite. ''' if sprite.eggFile is not None: spriteNP = self.resources.loadModel(sprite.eggFile) tex = None else: if sprite.video is not None: card = self.cardMaker.generate() tex = VideoPlayer.renderToTexture(self.resources, video=sprite.video, audio=sprite.audio) elif sprite.image is not None: card = self.cardMaker.generate() tex = self.resources.loadTexture(sprite.image) sprite.width = tex.getXSize() sprite.height = tex.getYSize() else: self.log.error('Could not determine type for sprite: %s' % sprite.name) return None spriteNP = NodePath(card) spriteNP.setTexture(tex) nodeName = self.getSpriteNodeName(sprite.name) spriteNP.setName(nodeName) spriteNP.setPos(0, 1, 0) spriteNP.setScale(sprite.width, 1.0, sprite.height) spriteNP.setTransparency(1) spriteNP.reparentTo(self.sprite2d) spriteNP.setDepthTest(False) spriteNP.setDepthWrite(False) spriteNP.setBin("fixed", PanoConstants.RENDER_ORDER_SPRITES) spriteNP.setPythonTag('sprite', sprite) if sprite.video is not None: spriteNP.setPythonTag('video', tex) tex.setLoop(True) tex.play() return SpriteRenderInterface(spriteNP)
class CogdoMazeGameIntro(CogdoGameMovie): def __init__(self, maze, exit, rng): CogdoGameMovie.__init__(self) self._maze = maze self._exit = exit self._rng = RandomNumGen(rng) self._camTarget = None self._state = 0 self._suits = [] return def _getRandomLine(self, lineList): return CogdoUtil.getRandomDialogueLine(lineList, self._rng) def displayLine(self, who, text): self._dialogueLabel.node().setText(text) if who == 'toon': self.toonHead.reparentTo(aspect2d) self.cogHead.reparentTo(hidden) self._toonDialogueSfx.play() self.toonHead.setClipPlane(self.clipPlane) else: self.toonHead.reparentTo(hidden) self.cogHead.reparentTo(aspect2d) self._cogDialogueSfx.play() self.cogHead.setClipPlane(self.clipPlane) def makeSuit(self, suitType): suit = Suit.Suit() dna = SuitDNA.SuitDNA() dna.newSuit(suitType) suit.setStyle(dna) suit.isDisguised = 1 suit.generateSuit() suit.setScale(1, 1, 2) suit.setPos(0, 0, -4.4) suit.reparentTo(self.toonHead) for part in suit.getHeadParts(): part.hide() def load(self): CogdoGameMovie.load(self) self.toonDNA = ToonDNA.ToonDNA() self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14) self.toonHead = Toon.Toon() self.toonHead.setDNA(self.toonDNA) self.makeSuit('sc') self.toonHead.getGeomNode().setDepthWrite(1) self.toonHead.getGeomNode().setDepthTest(1) self.toonHead.loop('neutral') self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18) self.toonHead.reparentTo(hidden) self.toonHead.startBlink() self.cogHead = Suit.Suit() self.cogDNA = SuitDNA.SuitDNA() self.cogDNA.newSuit('ms') self.cogHead.setDNA(self.cogDNA) self.cogHead.getGeomNode().setDepthWrite(1) self.cogHead.getGeomNode().setDepthTest(1) self.cogHead.loop('neutral') self.cogHead.setPosHprScale(-0.73, 0, -1.46, 180, 0, 0, 0.14, 0.14, 0.14) self.cogHead.reparentTo(hidden) self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip')) self.clipPlane.node().setPlane(Plane(0, 0, 1, 0)) self.clipPlane.setPos(0, 0, 2.45) audioMgr = base.cogdoGameAudioMgr self._cogDialogueSfx = audioMgr.createSfx('cogDialogue') self._toonDialogueSfx = audioMgr.createSfx('toonDialogue') suitData = Globals.SuitData[Globals.SuitTypes.Boss] bossSuit = Suit.Suit() bossSuit.nametag3d.stash() bossSuit.nametag.destroy() d = SuitDNA.SuitDNA() d.newSuit('ms') bossSuit.setDNA(d) bossSuit.setScale(suitData['scale']) bossSuit.loop('neutral') bossSuit.reparentTo(render) bossSuit.setPos(self._exit, -5, -5, 0) bossSuit.lookAt(self._exit) self._suits.append(bossSuit) self._camHelperNode = NodePath('CamHelperNode') self._camHelperNode.reparentTo(render) dialogue = TTLocalizer.CogdoMazeIntroMovieDialogue introDuration = Globals.IntroDurationSeconds waitDuration = introDuration / len(dialogue) def start(): camera.wrtReparentTo(render) self._exit.open(animate=False) def showBoss(): self._setCamTarget(bossSuit, 20, offset=Point3(0, 0, 7), angle=Point3(0, 15, 0)) bossSuit.loop('victory') self._state = 1 def showExit(): self._setCamTarget(self._exit, 10, offset=Point3(0, 0, 0), angle=Point3(0, 60, 0)) self._exit.close() self._state = 2 showExitIval = Parallel(camera.posInterval(waitDuration * 0.5, (10, -25, 20), other=self._exit, blendType='easeInOut'), Sequence(Wait(waitDuration * 0.25), Func(bossSuit.play, 'effort'), camera.hprInterval(waitDuration * 0.25, (30, -30, 0), blendType='easeInOut'), Func(self._exit.close), Wait(waitDuration * 0.5))) def showWaterCooler(): wc = self._maze.getWaterCoolers()[0] self._setCamTarget(wc, 25, angle=Point3(-30, 60, 0)) camera.wrtReparentTo(self._camHelperNode) self._state = 3 def end(): self._stopUpdateTask() self._ival = Sequence(Func(start), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[0])), showExitIval, Func(showWaterCooler), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[1])), Wait(waitDuration), Func(showBoss), bossSuit.hprInterval(1.0, bossSuit.getHpr() + Point3(180, 0, 0), blendType='easeInOut'), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[2])), Wait(waitDuration - 1.0), Func(end)) self._startUpdateTask() def _setCamTarget(self, targetNP, distance, offset = Point3(0, 0, 0), angle = Point3(0, 0, 0)): camera.wrtReparentTo(render) self._camTarget = targetNP self._camOffset = offset self._camAngle = angle self._camDistance = distance self._camHelperNode.setPos(self._camTarget, self._camOffset) self._camHelperNode.setHpr(self._camTarget, 180 + self._camAngle[0], self._camAngle[1], self._camAngle[2]) camera.setPos(self._camHelperNode, 0, self._camDistance, 0) def _updateTask(self, task): dt = globalClock.getDt() if self._state == 1: self._camHelperNode.setPos(self._camTarget.getPos() + self._camOffset) camera.setPos(self._camHelperNode, 0, self._camDistance, 0) camera.lookAt(self._camTarget, 0, 0, 4) elif self._state == 2: camera.lookAt(self._camTarget, 0, 0, 5) elif self._state == 3: self._camHelperNode.setHpr(self._camHelperNode, dt, dt, 0) camera.setY(camera, 0.8 * dt) camera.lookAt(self._camTarget, 0, 0, 3) return task.cont def unload(self): self._exit = None self._camTarget = None self._camHelperNode.removeNode() del self._camHelperNode for suit in self._suits: suit.cleanup() suit.removeNode() suit.delete() self._suits = [] CogdoGameMovie.unload(self) del self._cogDialogueSfx del self._toonDialogueSfx self.toonHead.stopBlink() self.toonHead.stop() self.toonHead.removeNode() self.toonHead.delete() del self.toonHead self.cogHead.stop() self.cogHead.removeNode() self.cogHead.delete() del self.cogHead return
class PartyEditorGridElement(DirectButton): __module__ = __name__ notify = directNotify.newCategory('PartyEditorGridElement') def __init__(self, partyEditor, id, isDecoration, checkSoldOutAndPaidStatusAndAffordability, **kw): self.partyEditor = partyEditor self.id = id self.isDecoration = isDecoration self.checkSoldOutAndPaidStatusAndAffordability = checkSoldOutAndPaidStatusAndAffordability if self.isDecoration: self.name = TTLocalizer.PartyDecorationNameDict[self.id]['editor'] colorList = ((1.0, 1.0, 1.0, 1.0), (0.0, 0.0, 1.0, 1.0), (0.0, 1.0, 1.0, 1.0), (0.5, 0.5, 0.5, 1.0)) self.geom = self.partyEditor.partyPlanner.gui.find( '**/%s' % PartyGlobals.DecorationInformationDict[self.id]['gridAsset']) else: self.name = TTLocalizer.PartyActivityNameDict[self.id]['editor'] colorList = ((1.0, 1.0, 1.0, 1.0), (0.0, 1.0, 0.0, 1.0), (1.0, 1.0, 0.0, 1.0), (0.5, 0.5, 0.5, 1.0)) self.geom = self.partyEditor.partyPlanner.gui.find( '**/%s' % PartyGlobals.ActivityInformationDict[self.id]['gridAsset']) optiondefs = (('geom', self.geom, None), ('geom_scale', 1.0, None), ('geom_color', colorList[0], None), ('geom1_color', colorList[0], None), ('geom2_color', colorList[0], None), ('geom3_color', colorList[0], None), ('relief', None, None)) self.defineoptions(kw, optiondefs) DirectButton.__init__(self, self.partyEditor.parent) self.initialiseoptions(PartyEditorGridElement) self.setName('%sGridElement' % self.name) self.bind(DirectGuiGlobals.B1PRESS, self.clicked) self.bind(DirectGuiGlobals.B1RELEASE, self.released) self.bind(DirectGuiGlobals.ENTER, self.mouseEnter) self.bind(DirectGuiGlobals.EXIT, self.mouseExit) self.uprightNodePath = NodePath('%sUpright' % self.name) self.uprightNodePath.reparentTo(self) rollOverZOffset = self.getGridSize()[1] / 30.0 self.rolloverTitle = DirectLabel(relief=None, parent=self.uprightNodePath, pos=Point3(0.0, 0.0, rollOverZOffset), text=self.name, text_fg=(1.0, 1.0, 1.0, 1.0), text_shadow=(0.0, 0.0, 0.0, 1.0), text_scale=0.075) self.rolloverTitle.stash() self.stash() self.overValidSquare = False self.lastValidPosition = None self.setColorScale(0.9, 0.9, 0.9, 0.7) self.setTransparency(True) self.mouseOverTrash = False self.centerGridSquare = None return def getCorrectRotation(self): r = self.getR() if r == 90.0: r = 270.0 elif r == 270.0: r = 90.0 if self.id == PartyGlobals.ActivityIds.PartyCannon: return PartyUtils.convertDegreesToPartyGrid(r + 180.0) return PartyUtils.convertDegreesToPartyGrid(r) def getDecorationTuple(self, x, y): return (self.id, self.centerGridSquare.x, PartyGlobals.PartyEditorGridSize[1] - 1 - self.centerGridSquare.y, self.getCorrectRotation()) def getActivityTuple(self, x, y): return (self.id, self.centerGridSquare.x, PartyGlobals.PartyEditorGridSize[1] - 1 - self.centerGridSquare.y, self.getCorrectRotation()) def attach(self, mouseEvent): PartyEditorGridElement.notify.debug('attached grid element %s' % self.name) taskMgr.remove('gridElementDragTask%s' % self.name) vWidget2render2d = self.getPos(render2d) vMouse2render2d = Point3(mouseEvent.getMouse()[0], 0, mouseEvent.getMouse()[1]) taskMgr.add(self.elementDragTask, 'gridElementDragTask%s' % self.name) self.unstash() self.rolloverTitle.unstash() self.uprightNodePath.reparentTo(self) self.setPosHprToDefault() def elementDragTask(self, state): mwn = base.mouseWatcherNode if mwn.hasMouse(): vMouse2render2d = Point3(mwn.getMouse()[0], 0, mwn.getMouse()[1]) newPos = vMouse2render2d if newPos[0] > PartyGlobals.PartyEditorGridBounds[0][0] and newPos[ 0] < PartyGlobals.PartyEditorGridBounds[1][0] and newPos[ 2] < PartyGlobals.PartyEditorGridBounds[0][ 1] and newPos[ 2] > PartyGlobals.PartyEditorGridBounds[1][1]: centerGridSquare = self.snapToGrid(newPos) if centerGridSquare is not None: self.centerGridSquare = centerGridSquare if not self.overValidSquare: self.setOverValidSquare(True) if self.mouseOverTrash: self.setOverTrash(False) return Task.cont if self.id != PartyGlobals.ActivityIds.PartyClock and newPos[ 0] > PartyGlobals.PartyEditorTrashBounds[0][0] and newPos[ 0] < PartyGlobals.PartyEditorTrashBounds[1][ 0] and newPos[ 2] < PartyGlobals.PartyEditorTrashBounds[0][ 1] and newPos[ 2] > PartyGlobals.PartyEditorTrashBounds[ 1][1]: if not self.mouseOverTrash: self.setOverTrash(True) elif self.mouseOverTrash: self.setOverTrash(False) self.setPos(render2d, newPos) if self.overValidSquare: self.setOverValidSquare(False) return Task.cont def setOverTrash(self, value): self.mouseOverTrash = value if value: self.partyEditor.trashCanButton[ 'state'] = DirectGuiGlobals.DISABLED self.setColorScale(1.0, 0.0, 0.0, 1.0) else: self.partyEditor.trashCanButton['state'] = DirectGuiGlobals.NORMAL self.setColorScale(0.9, 0.9, 0.9, 0.7) def setOverValidSquare(self, value): self.overValidSquare = value if value: self.setColorScale(1.0, 1.0, 1.0, 1.0) else: self.setColorScale(0.9, 0.9, 0.9, 0.7) def removeFromGrid(self): if self.centerGridSquare is not None: self.partyEditor.partyEditorGrid.removeElement( self.centerGridSquare, self.getGridSize()) self.setOverValidSquare(False) self.lastValidPosition = None self.stash() return def snapToGrid(self, newPos): gridSquare = self.getGridSquareFromPosition(newPos) if gridSquare == None: self.setPosHprToDefault() self.setPos(render2d, newPos) return elif not self.partyEditor.partyEditorGrid.checkGridSquareForAvailability( gridSquare, self.getGridSize()): self.setPos(render2d, newPos) return self.setPosHprBasedOnGridSquare(gridSquare) return gridSquare def getGridSize(self): if self.isDecoration: return PartyGlobals.DecorationInformationDict[self.id]['gridsize'] else: return PartyGlobals.ActivityInformationDict[self.id]['gridsize'] def setPosHprToDefault(self): self.setR(0.0) self.uprightNodePath.setR(0.0) def setPosHprBasedOnGridSquare(self, gridSquare): gridPos = gridSquare.getPos() if self.getGridSize()[0] % 2 == 0: gridPos.setX(gridPos[0] + PartyGlobals.PartyEditorGridSquareSize[0] / 2.0) if self.getGridSize()[1] % 2 == 0: gridPos.setZ(gridPos[2] + PartyGlobals.PartyEditorGridSquareSize[1] / 2.0) if self.id != PartyGlobals.ActivityIds.PartyFireworks: if gridPos[0] > PartyGlobals.PartyEditorGridCenter[ 0] + PartyGlobals.PartyEditorGridRotateThreshold: self.setR(90.0) self.uprightNodePath.setR(-90.0) elif gridPos[0] < PartyGlobals.PartyEditorGridCenter[ 0] - PartyGlobals.PartyEditorGridRotateThreshold: self.setR(270.0) self.uprightNodePath.setR(-270.0) elif gridPos[2] < PartyGlobals.PartyEditorGridCenter[ 1] - PartyGlobals.PartyEditorGridRotateThreshold: self.setR(180.0) self.uprightNodePath.setR(-180.0) else: self.setR(0.0) self.uprightNodePath.setR(0.0) else: self.setR(270.0) self.uprightNodePath.setR(-270.0) self.setPos(render2d, gridPos) self.lastValidPosition = gridPos def getGridSquareFromPosition(self, newPos): localX = newPos[0] - PartyGlobals.PartyEditorGridBounds[0][0] localY = newPos[2] - PartyGlobals.PartyEditorGridBounds[1][1] x = int(localX / PartyGlobals.PartyEditorGridSquareSize[0]) y = int(localY / PartyGlobals.PartyEditorGridSquareSize[1]) y = PartyGlobals.PartyEditorGridSize[1] - 1 - y return self.partyEditor.partyEditorGrid.getGridSquare(x, y) def detach(self, mouseEvent): taskMgr.remove('gridElementDragTask%s' % self.name) self.rolloverTitle.stash() if self.overValidSquare: self.partyEditor.partyEditorGrid.registerNewElement( self, self.centerGridSquare, self.getGridSize()) self.partyEditor.updateCostsAndBank() self.partyEditor.handleMutuallyExclusiveActivities() elif self.lastValidPosition is not None: if self.mouseOverTrash: self.partyEditor.trashCanButton[ 'state'] = DirectGuiGlobals.NORMAL self.lastValidPosition = None self.partyEditor.updateCostsAndBank() self.stash() else: self.setPos(render2d, self.lastValidPosition) self.setOverValidSquare(True) self.partyEditor.partyEditorGrid.registerNewElement( self, self.centerGridSquare, self.getGridSize()) self.partyEditor.updateCostsAndBank() self.partyEditor.handleMutuallyExclusiveActivities() else: self.stash() self.checkSoldOutAndPaidStatusAndAffordability() return def placeInPartyGrounds(self, desiredXY=None): self.centerGridSquare = self.partyEditor.partyEditorGrid.getClearGridSquare( self.getGridSize(), desiredXY) if self.centerGridSquare is not None: self.setOverValidSquare(True) self.unstash() self.setPosHprBasedOnGridSquare(self.centerGridSquare) self.partyEditor.partyEditorGrid.registerNewElement( self, self.centerGridSquare, self.getGridSize()) self.partyEditor.updateCostsAndBank() self.partyEditor.partyPlanner.instructionLabel[ 'text'] = TTLocalizer.PartyPlannerEditorInstructionsPartyGrounds self.checkSoldOutAndPaidStatusAndAffordability() return True else: return False return def clicked(self, mouseEvent): PartyEditorGridElement.notify.debug('clicked grid element %s' % self.name) if self.centerGridSquare is not None: self.attach(mouseEvent) self.partyEditor.partyEditorGrid.removeElement( self.centerGridSquare, self.getGridSize()) return def released(self, mouseEvent): PartyEditorGridElement.notify.debug('released grid element %s' % self.name) self.detach(mouseEvent) def mouseEnter(self, mouseEvent): parent = self.getParent() self.reparentTo(parent) self.rolloverTitle.unstash() def mouseExit(self, mouseEvent): self.rolloverTitle.stash() def destroy(self): self.unbind(DirectGuiGlobals.B1PRESS) self.unbind(DirectGuiGlobals.B1RELEASE) self.unbind(DirectGuiGlobals.ENTER) self.unbind(DirectGuiGlobals.EXIT) DirectButton.destroy(self)
class CogdoExecutiveSuiteIntro(CogdoGameMovie): __module__ = __name__ notify = DirectNotifyGlobal.directNotify.newCategory( 'CogdoExecutiveSuiteIntro') introDuration = 7 cameraMoveDuration = 3 def __init__(self, shopOwner): CogdoGameMovie.__init__(self) self._shopOwner = shopOwner self._lookAtCamTarget = False self._camTarget = None self._camHelperNode = None self._toonDialogueSfx = None self.toonHead = None self.frame = None return def displayLine(self, text): self.notify.debug('displayLine') self._dialogueLabel.node().setText(text) self.toonHead.reparentTo(aspect2d) self._toonDialogueSfx.play() self.toonHead.setClipPlane(self.clipPlane) def makeSuit(self, suitType): self.notify.debug('makeSuit()') suit = Suit.Suit() dna = SuitDNA.SuitDNA() dna.newSuit(suitType) suit.setStyle(dna) suit.isDisguised = 1 suit.generateSuit() suit.setScale(1, 1, 2) suit.setPos(0, 0, -4.4) suit.reparentTo(self.toonHead) for part in suit.getHeadParts(): part.hide() suit.loop('neutral') def load(self): self.notify.debug('load()') CogdoGameMovie.load(self) backgroundGui = loader.loadModel( 'phase_5/models/cogdominium/tt_m_gui_csa_flyThru') self.bg = backgroundGui.find('**/background') self.chatBubble = backgroundGui.find('**/chatBubble') self.chatBubble.setScale(6.5, 6.5, 7.3) self.chatBubble.setPos(0.32, 0, -0.78) self.bg.setScale(5.2) self.bg.setPos(0.14, 0, -0.6667) self.bg.reparentTo(aspect2d) self.chatBubble.reparentTo(aspect2d) self.frame = DirectFrame(geom=self.bg, relief=None, pos=(0.2, 0, -0.6667)) self.bg.wrtReparentTo(self.frame) self.gameTitleText = DirectLabel( parent=self.frame, text=TTLocalizer.CogdoExecutiveSuiteTitle, scale=TTLocalizer.MRPgameTitleText * 0.8, text_align=TextNode.ACenter, text_font=getSignFont(), text_fg=(1.0, 0.33, 0.33, 1.0), pos=TTLocalizer.MRgameTitleTextPos, relief=None) self.chatBubble.wrtReparentTo(self.frame) self.frame.hide() backgroundGui.removeNode() self.toonDNA = ToonDNA.ToonDNA() self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14) self.toonHead = Toon.Toon() self.toonHead.setDNA(self.toonDNA) self.makeSuit('sc') self.toonHead.getGeomNode().setDepthWrite(1) self.toonHead.getGeomNode().setDepthTest(1) self.toonHead.loop('neutral') self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18) self.toonHead.reparentTo(hidden) self.toonHead.startBlink() self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip')) self.clipPlane.node().setPlane(Plane(0, 0, 1, 0)) self.clipPlane.setPos(0, 0, 2.45) self._toonDialogueSfx = loader.loadSfx( 'phase_3.5/audio/dial/AV_dog_long.mp3') self._camHelperNode = NodePath('CamHelperNode') self._camHelperNode.reparentTo(render) dialogue = TTLocalizer.CogdoExecutiveSuiteIntroMessage def start(): self.frame.show() base.setCellsAvailable( base.bottomCells + base.leftCells + base.rightCells, 0) def showShopOwner(): self._setCamTarget(self._shopOwner, -10, offset=Point3(0, 0, 5)) def end(): self._dialogueLabel.reparentTo(hidden) self.toonHead.reparentTo(hidden) self.frame.hide() base.setCellsAvailable( base.bottomCells + base.leftCells + base.rightCells, 1) self._stopUpdateTask() self._ival = Sequence( Func(start), Func(self.displayLine, dialogue), Func(showShopOwner), ParallelEndTogether( camera.posInterval(self.cameraMoveDuration, Point3(8, 0, 13), blendType='easeInOut'), camera.hprInterval(0.5, self._camHelperNode.getHpr(), blendType='easeInOut')), Wait(self.introDuration), Func(end)) self._startUpdateTask() return def _setCamTarget(self, targetNP, distance, offset=Point3(0, 0, 0), angle=Point3(0, 0, 0)): camera.wrtReparentTo(render) self._camTarget = targetNP self._camOffset = offset self._camAngle = angle self._camDistance = distance self._camHelperNode.setPos(self._camTarget, self._camOffset) self._camHelperNode.setHpr(self._camTarget, 180 + self._camAngle[0], self._camAngle[1], self._camAngle[2]) self._camHelperNode.setPos(self._camHelperNode, 0, self._camDistance, 0) def _updateTask(self, task): dt = globalClock.getDt() return task.cont def unload(self): self._shopOwner = None self._camTarget = None if hasattr(self, '_camHelperNode') and self._camHelperNode: self._camHelperNode.removeNode() del self._camHelperNode self.frame.destroy() del self.frame self.bg.removeNode() del self.bg self.chatBubble.removeNode() del self.chatBubble self.toonHead.stopBlink() self.toonHead.stop() self.toonHead.removeNode() self.toonHead.delete() del self.toonHead CogdoGameMovie.unload(self) return
def load(self): CogdoGameMovie.load(self) self.toonDNA = ToonDNA.ToonDNA() self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14) self.toonHead = Toon.Toon() self.toonHead.setDNA(self.toonDNA) self.makeSuit('sc') self.toonHead.getGeomNode().setDepthWrite(1) self.toonHead.getGeomNode().setDepthTest(1) self.toonHead.loop('neutral') self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18) self.toonHead.reparentTo(hidden) self.toonHead.startBlink() self.cogHead = Suit.Suit() self.cogDNA = SuitDNA.SuitDNA() self.cogDNA.newSuit('ms') self.cogHead.setDNA(self.cogDNA) self.cogHead.getGeomNode().setDepthWrite(1) self.cogHead.getGeomNode().setDepthTest(1) self.cogHead.loop('neutral') self.cogHead.setPosHprScale(-0.73, 0, -1.46, 180, 0, 0, 0.14, 0.14, 0.14) self.cogHead.reparentTo(hidden) self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip')) self.clipPlane.node().setPlane(Plane(0, 0, 1, 0)) self.clipPlane.setPos(0, 0, 2.45) audioMgr = base.cogdoGameAudioMgr self._cogDialogueSfx = audioMgr.createSfx('cogDialogue') self._toonDialogueSfx = audioMgr.createSfx('toonDialogue') suitData = Globals.SuitData[Globals.SuitTypes.Boss] bossSuit = Suit.Suit() bossSuit.nametag3d.stash() bossSuit.nametag.destroy() d = SuitDNA.SuitDNA() d.newSuit('ms') bossSuit.setDNA(d) bossSuit.setScale(suitData['scale']) bossSuit.loop('neutral') bossSuit.reparentTo(render) bossSuit.setPos(self._exit, -5, -5, 0) bossSuit.lookAt(self._exit) self._suits.append(bossSuit) self._camHelperNode = NodePath('CamHelperNode') self._camHelperNode.reparentTo(render) dialogue = TTLocalizer.CogdoMazeIntroMovieDialogue introDuration = Globals.IntroDurationSeconds waitDuration = introDuration / len(dialogue) def start(): camera.wrtReparentTo(render) self._exit.open(animate=False) def showBoss(): self._setCamTarget(bossSuit, 20, offset=Point3(0, 0, 7), angle=Point3(0, 15, 0)) bossSuit.loop('victory') self._state = 1 def showExit(): self._setCamTarget(self._exit, 10, offset=Point3(0, 0, 0), angle=Point3(0, 60, 0)) self._exit.close() self._state = 2 showExitIval = Parallel(camera.posInterval(waitDuration * 0.5, (10, -25, 20), other=self._exit, blendType='easeInOut'), Sequence(Wait(waitDuration * 0.25), Func(bossSuit.play, 'effort'), camera.hprInterval(waitDuration * 0.25, (30, -30, 0), blendType='easeInOut'), Func(self._exit.close), Wait(waitDuration * 0.5))) def showWaterCooler(): wc = self._maze.getWaterCoolers()[0] self._setCamTarget(wc, 25, angle=Point3(-30, 60, 0)) camera.wrtReparentTo(self._camHelperNode) self._state = 3 def end(): self._stopUpdateTask() self._ival = Sequence(Func(start), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[0])), showExitIval, Func(showWaterCooler), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[1])), Wait(waitDuration), Func(showBoss), bossSuit.hprInterval(1.0, bossSuit.getHpr() + Point3(180, 0, 0), blendType='easeInOut'), Func(self.displayLine, 'toon', self._getRandomLine(dialogue[2])), Wait(waitDuration - 1.0), Func(end)) self._startUpdateTask()
def getWheel(): return wheel.copyTo(NodePath())
def load(self): self.notify.debug('load()') CogdoGameMovie.load(self) backgroundGui = loader.loadModel( 'phase_5/models/cogdominium/tt_m_gui_csa_flyThru') self.bg = backgroundGui.find('**/background') self.chatBubble = backgroundGui.find('**/chatBubble') self.chatBubble.setScale(6.5, 6.5, 7.3) self.chatBubble.setPos(0.32, 0, -0.78) self.bg.setScale(5.2) self.bg.setPos(0.14, 0, -0.6667) self.bg.reparentTo(aspect2d) self.chatBubble.reparentTo(aspect2d) self.frame = DirectFrame(geom=self.bg, relief=None, pos=(0.2, 0, -0.6667)) self.bg.wrtReparentTo(self.frame) self.gameTitleText = DirectLabel( parent=self.frame, text=TTLocalizer.CogdoExecutiveSuiteTitle, scale=TTLocalizer.MRPgameTitleText * 0.8, text_align=TextNode.ACenter, text_font=getSignFont(), text_fg=(1.0, 0.33, 0.33, 1.0), pos=TTLocalizer.MRgameTitleTextPos, relief=None) self.chatBubble.wrtReparentTo(self.frame) self.frame.hide() backgroundGui.removeNode() self.toonDNA = ToonDNA.ToonDNA() self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14) self.toonHead = Toon.Toon() self.toonHead.setDNA(self.toonDNA) self.makeSuit('sc') self.toonHead.getGeomNode().setDepthWrite(1) self.toonHead.getGeomNode().setDepthTest(1) self.toonHead.loop('neutral') self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18) self.toonHead.reparentTo(hidden) self.toonHead.startBlink() self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip')) self.clipPlane.node().setPlane(Plane(0, 0, 1, 0)) self.clipPlane.setPos(0, 0, 2.45) self._toonDialogueSfx = loader.loadSfx( 'phase_3.5/audio/dial/AV_dog_long.mp3') self._camHelperNode = NodePath('CamHelperNode') self._camHelperNode.reparentTo(render) dialogue = TTLocalizer.CogdoExecutiveSuiteIntroMessage def start(): self.frame.show() base.setCellsAvailable( base.bottomCells + base.leftCells + base.rightCells, 0) def showShopOwner(): self._setCamTarget(self._shopOwner, -10, offset=Point3(0, 0, 5)) def end(): self._dialogueLabel.reparentTo(hidden) self.toonHead.reparentTo(hidden) self.frame.hide() base.setCellsAvailable( base.bottomCells + base.leftCells + base.rightCells, 1) self._stopUpdateTask() self._ival = Sequence( Func(start), Func(self.displayLine, dialogue), Func(showShopOwner), ParallelEndTogether( camera.posInterval(self.cameraMoveDuration, Point3(8, 0, 13), blendType='easeInOut'), camera.hprInterval(0.5, self._camHelperNode.getHpr(), blendType='easeInOut')), Wait(self.introDuration), Func(end)) self._startUpdateTask() return
def generateHullCache(modelClass): geom = loader.loadModel('models/shipparts/pir_m_shp_%s' % HullDict[modelClass]) stripPrefix(geom, 'model:') for node in geom.findAllMatches('**/omit'): parent = node.getParent() omit = parent.attachNewNode(ModelNode('omit')) node.reparentTo(omit) node.setName('geom') preFlatten(geom) logic = loader.loadModel('models/shipparts/pir_m_shp_%s_logic' % HullDict[modelClass]) locators = logic.find('**/locators') for side in [ 'left', 'right']: bad = locators.find('**/location_ropeLadder_0_%s' % side) if bad: bad.setName('location_ropeLadder_%s_0' % side) bad = locators.find('**/location_ropeLadder_1_%s' % side) if bad: bad.setName('location_ropeLadder_%s_1' % side) bad = locators.find('**/location_ropeLadder_1_%s1' % side) if bad: bad.setName('location_ropeLadder_%s_2' % side) collisions = logic.find('**/collisions') badPanel = collisions.find('**/collision_panel_3') if badPanel: badPanel.setName('collision_panel_2') collisions.find('**/collision_panel_0').setTag('Hull Code', '0') collisions.find('**/collision_panel_1').setTag('Hull Code', '1') collisions.find('**/collision_panel_2').setTag('Hull Code', '2') walls = collisions.find('**/collision_walls') if walls: walls.setTag('Hull Code', '255') else: collisions.attachNewNode('collision_walls') shipToShipCollide = collisions.find('**/collision_shiptoship') shipToShipCollide.setCollideMask(PiratesGlobals.ShipCollideBitmask) deck = collisions.find('**/collision_deck') if not deck: deck = collisions.attachNewNode('deck') mask = deck.getCollideMask() mask ^= PiratesGlobals.FloorBitmask mask |= PiratesGlobals.ShipFloorBitmask deck.setCollideMask(mask) floors = collisions.find('**/collision_floors') if not floors: floors = collisions.find('**/collision_floor') mask = floors.getCollideMask() mask ^= PiratesGlobals.FloorBitmask mask |= PiratesGlobals.ShipFloorBitmask floors.setCollideMask(mask) floors.setTag('Hull Code', str(255)) geomHigh = geom.find('**/lod_high') geomMed = geom.find('**/lod_medium') if not geomMed: geomMed = geom.find('**/low_medium') if not geomMed: geomMed = geomHigh.copyTo(NodePath()) geomLow = geom.find('**/lod_low') if not geomLow: geomLow = geomMed.copyTo(NodePath()) geomSuperLow = geom.find('**/lod_superlow') if not geomSuperLow: geomSuperLow = geomLow.copyTo(NodePath()) geomHigh.setName('high') geomMed.setName('med') geomLow.setName('low') geomSuperLow.setName('superlow') if modelClass in [ 21, 22, 23]: spike = loader.loadModel('models/shipparts/pir_m_shp_ram_spike') spikeTrans = locators.find('**/location_ram').getTransform(locators) spike.setTransform(spikeTrans) spike.flattenLight() spikeHi = spike.find('**/lod_high') spikeMed = spike.find('**/lod_medium') spikeLow = spike.find('**/lod_low') spikeHi.copyTo(geomHigh) spikeMed.copyTo(geomMed) spikeLow.copyTo(geomLow) spikeLow.copyTo(geomSuperLow) flipRoot = NodePath('root') collisions.reparentTo(flipRoot) locators.reparentTo(flipRoot) geomHigh.reparentTo(flipRoot) geomMed.reparentTo(flipRoot) geomLow.reparentTo(flipRoot) geomSuperLow.reparentTo(flipRoot) flipRoot.setH(180) flipRoot.flattenLight() omits = flipRoot.findAllMatches('**/omit') for node in omits: node.flattenStrong() for group in [ 'static', 'transparent', 'ropeLadder_*', 'stripeA', 'stripeB', 'pattern']: for node in flipRoot.findAllMatches('**/%s' % group): name = node.getName() for subNode in node.findAllMatches('**/*'): subNode.setName(name) node.flattenStrong() node.setName(name) geomHigh.detachNode() geomMed.detachNode() geomLow.detachNode() geomSuperLow.detachNode() locators.detachNode() collisions.detachNode() genericGeoms = [ geomHigh, geomMed, geomLow, geomSuperLow] customGeoms = [ x.copyTo(NodePath()) for x in genericGeoms ] for np in genericGeoms: trans = np.find('**/transparent') if trans: trans.stash() np.flattenLight() sails = np.findAllMatches('**/sails') sails.stash() omits = np.findAllMatches('**/omit') omits.stash() for node in omits: node.node().setPreserveTransform(node.node().PTDropNode) generic = NodePath('generic') np.findAllMatches('**/+GeomNode').wrtReparentTo(generic) np.findAllMatches('*').detach() generic.flattenStrong() generic.reparentTo(np) stripAttribs(generic, TextureAttrib) stripAttribs(generic, TransparencyAttrib) stripAttribs(generic, CullBinAttrib) generic.setBin('ground', 1) collapse(generic) sails.unstash() sails.reparentTo(np) for node in sails: node.node().setPreserveTransform(node.node().PTDropNode) if trans: trans.unstash() trans.flattenStrong() if trans.node().isOfType(ModelNode.getClassType()): trans.node().setPreserveTransform(ModelNode.PTDropNode) deck = np.find('**/=cam=shground') if deck: deck.setName('deck') omits.unstash() for np in customGeoms: collapse(np.find('**/static')) data = HullCache() data.root = NodePath('hull') data.genericGeoms = genericGeoms data.customGeoms = customGeoms data.collisions = collisions data.locators = locators return data
class CogdoFlyingLevelQuadrant: notify = directNotify.newCategory('CogdoFlyingLevelQuadrant') def __init__(self, serialNum, model, level, parent): self.serialNum = serialNum self._model = model self._level = level self._root = NodePath('Quadrant' + repr(serialNum)) self._model.reparentTo(self._root) self._root.reparentTo(parent) self._visible = True self.platforms = {} self.gatherables = [] self.obstacles = [] self._playing = False self._obstaclesRoot = NodePath('obstacles') self._obstaclesRoot.reparentTo(self._root) self._initObstacles(self._obstaclesRoot) self._gatherablesRoot = NodePath('gatherables') self._gatherablesRoot.reparentTo(self._root) self._initGatherables(self._gatherablesRoot) self._platformsRoot = NodePath('platforms') self._platformsRoot.reparentTo(self._model) self._initPlatforms(self._platformsRoot) self._optimize() self.place() def _optimize(self): lightCones = NodePath('lightCones') for np in self._platformsRoot.findAllMatches('**/*lightCone*'): np.wrtReparentTo(lightCones) lightCones.reparentTo(self._model) node = self._model.find('**/ducts') if not node.isEmpty(): node.flattenStrong() for np in node.getChildren(): np.wrtReparentTo(self._model) node = self._model.find('**/nests') if not node.isEmpty(): for np in node.getChildren(): np.flattenStrong() np.wrtReparentTo(self._model) for np in self._model.findAllMatches('**/*LayerStack*'): np.wrtReparentTo(self._model) if not self._model.find('**/static').isEmpty(): for np in self._model.find('**/static').getChildren(): np.wrtReparentTo(self._model) self._model.flattenMedium() def _initPlatforms(self, parent): platformModels = self._model.findAllMatches('**/%s' % Globals.Level.PlatformName) for platformModel in platformModels: platform = CogdoFlyingPlatform(platformModel, parent=parent) self.platforms[platform.getName()] = platform def _destroyPlatforms(self): for platform in list(self.platforms.values()): platform.destroy() del self.platforms def _initGatherables(self, parent): self.generateGatherables(self._model, parent=parent) if Globals.Level.SpawnLaffPowerupsInNests: self.generateNestPowerups(self._model, parent=parent) def generateNestPowerups(self, gatherableModel, parent): nests = gatherableModel.findAllMatches( '**/%s;+s' % Globals.Level.LegalEagleNestName) for nest in nests: offset = Globals.Level.LaffPowerupNestOffset pickup = self._level.gatherableFactory.createPowerup( Globals.Level.GatherableTypes.LaffPowerup) pickup.reparentTo(parent) pickup.setPos(parent, nest.getPos(parent) + offset) if Globals.Level.AddSparkleToPowerups: sparkles = self._level.gatherableFactory.createSparkles( Vec4(1, 1, 1, 1), Vec4(1, 1, 0, 1), 10.0) sparkles.reparentTo(pickup) sparkles.setPos(0, 0, 1) sparkles.start() self.gatherables.append(pickup) def generateGatherables(self, gatherableModel, parent=None, spread=Globals.Level.GatherablesDefaultSpread): parent = parent or self._root mopath = Mopath.Mopath(name='gatherables') def generateMemos(): gatherPaths = gatherableModel.findAllMatches( '**/%s' % Globals.Level.GatherablesPathName) for gatherPath in gatherPaths: mopath.loadNodePath(gatherPath) t = 0.0 while t < mopath.getMaxT(): pickup = self._level.gatherableFactory.createMemo() pickup.reparentTo(parent) mopath.goTo(pickup, t) self.gatherables.append(pickup) t += spread gatherPath.removeNode() angleSpread = 360.0 / Globals.Level.NumMemosInRing gatherPaths = gatherableModel.findAllMatches( '**/%s' % Globals.Level.GatherablesRingName) for gatherPath in gatherPaths: mopath.loadNodePath(gatherPath) t = 0.0 while t < mopath.getMaxT(): angle = 0 r = 3 while angle < 360.0: pickup = self._level.gatherableFactory.createMemo() pickup.reparentTo(parent) mopath.goTo(pickup, t) pickup.setX( parent, pickup.getX() + r * math.cos(math.radians(angle))) pickup.setZ( parent, pickup.getZ() + r * math.sin(math.radians(angle))) self.gatherables.append(pickup) angle += angleSpread t += spread + 0.5 gatherPath.removeNode() def generatePropellers(): gatherables = gatherableModel.findAllMatches( '**/%s' % Globals.Level.PropellerName) for gatherable in gatherables: pickup = self._level.gatherableFactory.createPropeller() pickup.reparentTo(gatherable.getParent()) pickup.setPos(parent, gatherable.getPos(parent)) self.gatherables.append(pickup) gatherable.removeNode() def generatePowerUps(): for powerupType, locName in Globals.Level.PowerupType2Loc.items(): gatherables = gatherableModel.findAllMatches('**/%s' % locName) for gatherable in gatherables: pickup = self._level.gatherableFactory.createPowerup( powerupType) pickup.reparentTo(parent) pickup.setPos(parent, gatherable.getPos(parent)) if Globals.Level.AddSparkleToPowerups: sparkles = self._level.gatherableFactory.createSparkles( Vec4(1, 1, 1, 1), Vec4(1, 1, 0, 1), 10.0) sparkles.reparentTo(pickup) sparkles.setPos(0, 0, 1) sparkles.start() self.gatherables.append(pickup) gatherable.removeNode() generateMemos() generatePropellers() generatePowerUps() def _initObstacles(self, parent): def initWhirlwinds(): obstacles = self._root.findAllMatches('**/%s' % Globals.Level.WhirlwindName) for obstacleLoc in obstacles: motionPath = self._model.find( '**/%s%s' % (obstacleLoc.getName(), Globals.Level.WhirlwindPathName)) if motionPath.isEmpty(): motionPath = None obstacle = self._level.obstacleFactory.createWhirlwind( motionPath=motionPath) obstacle.model.reparentTo(parent) obstacle.model.setPos(parent, obstacleLoc.getPos(parent)) self.obstacles.append(obstacle) obstacleLoc.removeNode() return def initStreamers(): obstacles = self._model.findAllMatches('**/%s' % Globals.Level.StreamerName) for obstacleLoc in obstacles: obstacle = self._level.obstacleFactory.createFan() obstacle.model.reparentTo(parent) obstacle.model.setPos(parent, obstacleLoc.getPos(parent)) obstacle.model.setHpr(parent, obstacleLoc.getHpr(parent)) obstacle.model.setScale(parent, obstacleLoc.getScale(parent)) obstacle.setBlowDirection() if Globals.Level.AddParticlesToStreamers: particles = self._level.obstacleFactory.createStreamerParticles( Vec4(1, 1, 1, 1), Vec4(1, 1, 1, 1), 10.0) particles.reparentTo(obstacle.model) particles.start() self.obstacles.append(obstacle) obstacleLoc.removeNode() def initWalkingMinions(): motionPaths = self._model.findAllMatches( '**/%s' % Globals.Level.MinionWalkingPathName) for motionPath in motionPaths: obstacle = self._level.obstacleFactory.createWalkingMinion( motionPath=motionPath) obstacle.model.reparentTo(parent) obstacle.model.setPos(parent, motionPath.getPos(parent)) self.obstacles.append(obstacle) def initFlyingMinions(): motionPaths = self._model.findAllMatches( '**/%s' % Globals.Level.MinionFlyingPathName) for motionPath in motionPaths: obstacle = self._level.obstacleFactory.createFlyingMinion( motionPath=motionPath) obstacle.model.reparentTo(parent) obstacle.model.setPos(parent, motionPath.getPos(parent)) self.obstacles.append(obstacle) initWhirlwinds() initStreamers() initWalkingMinions() initFlyingMinions() def place(self): self._root.setPos(0, self._level.convertQuadNumToY(self.serialNum), 0) def destroy(self): if self._visible: self.offstage() self._destroyPlatforms() for obstacle in self.obstacles: obstacle.destroy() for gatherable in self.gatherables: gatherable.destroy() self._root.removeNode() del self._root del self._gatherablesRoot del self._obstaclesRoot del self._platformsRoot del self._level def onstage(self, elapsedTime=0.0): if self._visible: return self._root.unstash() for obstacle in self.obstacles: obstacle.startMoving(elapsedTime) for gatherable in self.gatherables: gatherable.show() self._visible = True def offstage(self): if not self._visible: return self._root.stash() for obstacle in self.obstacles: obstacle.stopMoving() for gatherable in self.gatherables: gatherable.hide() self._visible = False def update(self, dt): if self._visible: for gatherable in self.gatherables: gatherable.update(dt) for obstacle in self.obstacles: obstacle.update(dt) def getModel(self): return self._root
def getAsset(self): return (self.high.copyTo(NodePath()), self.med.copyTo(NodePath()), self.low.copyTo(NodePath()))
def generateMastCache(mastClass): data = MastCache() prefix = MastData[mastClass]['prefix'] height = MastData[mastClass]['maxHeight'] model_prefix = 'models/char/pir_r_shp_mst_%s' % prefix anim_prefix = 'models/char/pir_a_shp_mst_%s_' % prefix geom = loader.loadModel(model_prefix).find('**/+Character') stripPrefix(geom, 'model:') if mastClass == ShipGlobals.Masts.Fore_Multi: geom.findAllMatches('**/sail_0*').detach() for name in ('_1', '_1_rope', '_2', '_2_rope'): for node in geom.findAllMatches('**/boom%s' % name): node.setName('boom') preFlatten(geom) if mastClass in (6, 7, 8, 9, 10): for node in geom.findAllMatches('**/sail_0'): node.setName('skel_sail_0') for node in geom.findAllMatches('**/sail_1'): node.setName('skel_sail_1') for node in geom.findAllMatches('**/sail_2'): node.setName('skel_sail_2') for node in geom.findAllMatches('**/sail_0'): stripAttribs(node, TextureAttrib) for node in geom.findAllMatches('**/sail_1'): stripAttribs(node, TextureAttrib) for node in geom.findAllMatches('**/sail_2'): stripAttribs(node, TextureAttrib) geomSet = [ geom.find('**/lod_high'), geom.find('**/lod_medium'), geom.find('**/lod_low'), geom.find('**/lod_superlow')] tex = geomSet[0].find('**/static').findAllTextures('*')[0] logic = loader.loadModel(model_prefix + '_logic') stripPrefix(logic, 'model:') data.collisions = logic.find('**/collisions') if not data.collisions.find('**/collision_masts'): data.collisions.find('**/collision_mast_0').setName('collision_masts') sails = data.collisions.findAllMatches('**/collision_sails') for node in sails: node.setTag('Sail', '1') sails.wrtReparentTo(data.collisions.find('**/collision_masts')) geomSet[0].setName('high') geomSet[1].setName('med') geomSet[2].setName('low') geomSet[3].setName('superlow') data.charRoot = geom.node() data.breakAnim = (anim_prefix + 'break', anim_prefix + 'broken') data.hitAnim = anim_prefix + 'hit' for anim in metaAnims: data.metaAnims[anim] = anim_prefix + anim geom.findAllMatches('**/rigging_anchors').detach() geom.findAllMatches('**/breaks').detach() geom.findAllMatches('**/def_mast_base').detach() height = MastData[mastClass]['maxHeight'] matchSet = range(height) for i in range(height): matchSet = _[1] reducedSet = [] foundReduction = False for j in range(len(geomSet)): currGeom = geomSet[j].copyTo(NodePath()) for match in matchSet: cruft = currGeom.findAllMatches('**/*_%s*' % match) if cruft: cruft.detach() foundReduction = True [] if foundReduction or not matchSet: for group in [ 'static', 'transparent']: for node in currGeom.findAllMatches('**/%s' % group): node.flattenStrong() node.setName(group) reducedSet.append(currGeom) customSet = [] for np in reducedSet: sails = np.find('**/sails;+s') if not sails: np.attachNewNode(ModelNode('sails')) customSet.append(np.copyTo(NodePath())) for np in reducedSet: np.find('static').node().setPreserveTransform(ModelNode.PTDropNode) np.find('custom').node().setPreserveTransform(ModelNode.PTDropNode) np.find('**/sails').node().setPreserveTransform(ModelNode.PTDropNode) np.flattenStrong() trans = np.findAllMatches('**/transparent') if trans: for node in trans: node.node().setPreserveTransform(ModelNode.PTDropNode) node.stash() stripAttribs(np, TextureAttrib) for node in trans: node.unstash() stripAttribs(np, TextureAttrib) for np in customSet: np.flattenStrong() np.find('static').node().setPreserveTransform(ModelNode.PTDropNode) np.find('custom').node().setPreserveTransform(ModelNode.PTDropNode) np.find('**/sails').node().setPreserveTransform(ModelNode.PTDropNode) trans = np.findAllMatches('**/transparent') if trans: for node in trans: node.node().setPreserveTransform(ModelNode.PTDropNode) node.stash() stripAttribs(np, TextureAttrib) for node in trans: node.unstash() data.genericGeomSets.append(reducedSet) data.customGeomSets.append(customSet) NodePath(data.charRoot).removeChildren() data.collisions.reparentTo(NodePath(data.charRoot)) return data