def createSafeZone(self, dnaFile): assert (self.notify.debug("createParty()")) SafeZoneLoader.SafeZoneLoader.createSafeZone(self, dnaFile) parent = self.geom.getParent() geom = self.geom n = NodePath("PartyGroundRoot") n.reparentTo(parent) geom.reparentTo(n) geom.setPos(-10.0, 0.0, 0.0) self.geom = n # load the sun and moon self.loadSunMoon()
def __init__(self, parent, frameModel, startPlatformModel, endPlatformModel, quadLengthUnits, quadVisibilityAhead, quadVisibiltyBehind): self.parent = parent self.quadLengthUnits = quadLengthUnits self._halfQuadLengthUnits = quadLengthUnits / 2.0 self.quadVisibiltyAhead = quadVisibilityAhead self.quadVisibiltyBehind = quadVisibiltyBehind self._frameModel = frameModel self.root = NodePath('CogdoFlyingLevel') self.quadrantRoot = NodePath('QuadrantsRoot') self.quadrantRoot.reparentTo(self.root) self._startPlatformModel = startPlatformModel self._startPlatformModel.reparentTo(self.root) self._startPlatformModel.setZ(Globals.Level.StartPlatformHeight) self._endPlatformModel = endPlatformModel self._endPlatformModel.reparentTo(self.root) self._endPlatformModel.setZ(Globals.Level.EndPlatformHeight) self.wallR = self._frameModel.find('**/wallR') self.wallL = self._frameModel.find('**/wallL') self._exit = CogdoGameExit() self._exit.reparentTo(self._endPlatformModel) loc = self._endPlatformModel.find('**/exit_loc') offset = loc.getPos(render) self._exit.setPos(render, offset) self.quadrants = [] self.visibleQuadIndices = [] self._numQuads = 0 self._currentQuadNum = -1 self._camera = None self._initCollisions() self.upLimit = self._frameModel.find('**/limit_up').getZ(render) self.downLimit = self._frameModel.find('**/limit_down').getZ(render) self.leftLimit = self._frameModel.find('**/limit_left').getX(render) - 30.0 self.rightLimit = self._frameModel.find('**/limit_right').getX(render) + 30.0 self.backLimit = -self.quadLengthUnits self.forwardLimit = self.quadLengthUnits * 20 self._frameModel.flattenStrong() self.gatherableFactory = CogdoFlyingGatherableFactory() self.obstacleFactory = CogdoFlyingObtacleFactory() return
def addToon(self, toon): marker = NodePath('toon_marker-%i' % toon.doId) marker.reparentTo(self) self._getToonMarker(toon).copyTo(marker) marker.setColor(toon.style.getHeadColor()) if toon.isLocal(): marker.setScale(Globals.Gui.LocalMarkerScale) marker.setBin('fixed', 10) else: marker.setScale(Globals.Gui.MarkerScale) marker.setBin('fixed', 5) marker.flattenStrong() self._toonMarkers[toon] = marker
def getAIShip(self, shipClass): from pirates.ship.ShipAI import ShipAI ShipAI = ShipAI modelClass = ShipGlobals.getModelClass(shipClass) hull = self.getHull(modelClass, 0) root = NodePath('Ship') collisions = root.attachNewNode('collisions') mastSetup = ShipGlobals.getMastSetup(shipClass) for data in [(0, 'location_mainmast_0'), (1, 'location_mainmast_1'), (2, 'location_mainmast_2'), (3, 'location_aftmast*'), (4, 'location_foremast*')]: mastData = mastSetup.get(data[0]) if mastData: mast = self.mastSets[mastData[0]].getMastSet(mastData[1] - 1) model = NodePath(mast.charRoot) model.setPos( hull.locators.find('**/%s' % data[1]).getPos( hull.locators)) model.setHpr( hull.locators.find('**/%s' % data[1]).getHpr( hull.locators)) model.setScale( hull.locators.find('**/%s' % data[1]).getScale( hull.locators)) if modelClass > ShipGlobals.INTERCEPTORL3 or data[0] != 3: mastCode = str(data[0]) else: mastCode = '0' mast.collisions.find('**/collision_masts').setTag( 'Mast Code', mastCode) collisions.node().stealChildren(mast.collisions.node()) continue collisions.node().stealChildren(hull.collisions.node()) hull.locators.reparentTo(root) ship = ShipAI.ShipAI(root, collisions, hull.locators) ship.modelRoot.setTag('Mast Code', str(255)) ship.modelRoot.setTag('Hull Code', str(255)) return ship
def loadModels(self): self.tramp = self.root.attachNewNode(self.uniqueName('tramp')) self.screenPlaneElements = NodePath(self.uniqueName('screenPlane')) self.trampActor = Actor('phase_13/models/parties/trampoline_model', {'emptyAnim': 'phase_13/models/parties/trampoline_anim'}) self.trampActor.reparentTo(self.tramp) if self.texture: reskinNode = self.tramp.find('**/trampoline/__Actor_modelRoot/-GeomNode') reskinNode.setTexture(loader.loadTexture(self.texture), 100) self.surface = NodePath(self.uniqueName('trampSurface')) self.surface.reparentTo(self.tramp) self.surface.setZ(self.trampHeight) self.trampActor.controlJoint(self.surface, 'modelRoot', 'trampoline_joint1') self.sign.setPos(PartyGlobals.TrampolineSignOffset) self.beans = [ loader.loadModelCopy('phase_4/models/props/jellybean4') for i in range(self.numJellyBeans) ] for bean in self.beans: bean.find('**/jellybean').setP(-35.0) bean.setScale(3.0) bean.setTransparency(True) bean.reparentTo(self.tramp) bean.stash() self.beans[-1].setScale(8.0)
def __updateModel(self): if self.editModel: # create a image with the same size of the texture textureSize = (self.editTexture.getXSize(), self.editTexture.getYSize()) # create a dummy node, where we setup the parameters for the background rendering loadPaintNode = NodePath(PandaNode('paintnode')) loadPaintNode.setShader(Shader.make(self.backgroundShader), 10001) loadPaintNode.setShaderInput('texsize', textureSize[0], textureSize[1], 0, 0) # copy the state onto the camera self.modelColorCam.node().setInitialState(loadPaintNode.getState()) # the camera gets a special bitmask, to show/hide models from it self.modelColorCam.node().setCameraMask(BitMask32.bit(1)) if False: # doesnt work, but would be nicer (not messing with the default render state) hiddenNode = NodePath(PandaNode('hiddennode')) hiddenNode.hide(BitMask32.bit(1)) showTroughNode = NodePath(PandaNode('showtroughnode')) showTroughNode.showThrough(BitMask32.bit(1)) self.modelColorCam.node().setTagStateKey( 'show-on-backrender-cam') self.modelColorCam.node().setTagState('False', hiddenNode.getState()) self.modelColorCam.node().setTagState( 'True', showTroughNode.getState()) render.setTag('show-on-backrender-cam', 'False') self.editModel.setTag('show-on-backrender-cam', 'True') else: # make only the model visible to the background camera render.hide(BitMask32.bit(1)) self.editModel.showThrough(BitMask32.bit(1))
def getFlyBallBubble(self): if self.__flyBallBubble == None: bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS) node = CollisionNode('flyBallBubble') node.addSolid(bubble) node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask) node.setIntoCollideMask(BitMask32.allOff()) self.__flyBallBubble = NodePath(node) self.flyBallHandler = CollisionHandlerEvent() self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index) return self.__flyBallBubble
def loadLever(self): self.lever = self.root.attachNewNode('%sLever' % self.activityName) self.leverModel = self.party.defaultLeverModel.copyTo(self.lever) self.controlColumn = NodePath('cc') column = self.leverModel.find('**/column') column.getChildren().reparentTo(self.controlColumn) self.controlColumn.reparentTo(column) self.stickHinge = self.controlColumn.attachNewNode('stickHinge') self.stick = self.party.defaultStickModel.copyTo(self.stickHinge) self.stickHinge.setHpr(0.0, 90.0, 0.0) self.stick.setHpr(0, -90.0, 0) self.stick.flattenLight() self.bottom = self.leverModel.find('**/bottom') self.bottom.wrtReparentTo(self.controlColumn) self.bottomPos = self.bottom.getPos() cs = CollisionSphere(0.0, 1.35, 2.0, 1.0) cs.setTangible(False) cn = CollisionNode(self.leverTriggerEvent) cn.addSolid(cs) cn.setIntoCollideMask(OTPGlobals.WallBitmask) self.leverTrigger = self.root.attachNewNode(cn) self.leverTrigger.reparentTo(self.lever) self.leverTrigger.stash() cs = CollisionTube(0.0, 2.7, 0.0, 0.0, 2.7, 3.0, 1.2) cn = CollisionNode('levertube') cn.addSolid(cs) cn.setIntoCollideMask(OTPGlobals.WallBitmask) self.leverTube = self.leverModel.attachNewNode(cn) host = base.cr.doId2do.get(self.party.partyInfo.hostId) if host is None: self.notify.debug( '%s loadLever : Host has left the game before lever could be created.' % self.activityName) return scale = host.getGeomNode().getChild(0).getSz(render) self.leverModel.setScale(scale) self.controlColumn.setPos(0, 0, 0) host.setPosHpr(self.lever, 0, 0, 0, 0, 0, 0) host.pose('leverNeutral', 0) host.update() pos = host.rightHand.getPos(self.controlColumn) self.controlColumn.setPos(pos[0], pos[1], pos[2] - 1) self.bottom.setZ(host, 0.0) self.bottom.setPos(self.bottomPos[0], self.bottomPos[1], self.bottom.getZ()) lookAtPoint = Point3(0.3, 0, 0.1) lookAtUp = Vec3(0, -1, 0) self.stickHinge.lookAt(host.rightHand, lookAtPoint, lookAtUp) host.play('walk') host.update() return
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.CogdoBarrelRoomTitle, 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.ogg') self._camHelperNode = NodePath('CamHelperNode') self._camHelperNode.reparentTo(render) dialogue = TTLocalizer.CogdoBarrelRoomIntroDialog def start(): self.frame.show() base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 0) def end(): self._dialogueLabel.reparentTo(hidden) self.toonHead.reparentTo(hidden) self.frame.hide() base.setCellsActive(base.bottomCells + base.leftCells + base.rightCells, 1) self._stopUpdateTask() self._ival = Sequence(Func(start), Func(self.displayLine, dialogue), Wait(CogdoBarrelRoomConsts.BarrelRoomIntroTimeout), Func(end)) self._startUpdateTask() return
def _initVisuals(self): RepairMincroGame._initVisuals(self) self.model = loader.loadModel('models/gui/pir_m_gui_srp_pitching_main') self.board = self.model.find('**/piece_hull') self.board.reparentTo(self) self.board.setPos(0.0, 0.0, 0.19) self.crossHair = self.model.find('**/crosshair') self.crossHair.reparentTo(base.a2dBackground) self.crossHair.setBin('fixed', 45) self.crossHair.setScale(1.0) self.crossHair.setColorScale(0.0, 1.0, 0.0, 1.0) self.crossHair.stash() self.bucketIdle = self.model.find('**/pitchCursor/idle') self.bucketIdle.reparentTo(base.a2dBackground) self.bucketIdle.setBin('fixed', 45) self.bucketIdle.setScale(1.3500000000000001) self.bucketIdle.stash() self.bucket = self.bucketIdle.copyTo(NodePath()) self.bucket.reparentTo(base.a2dBackground) self.bucket.setHpr(0, 0, 90) self.bucket.setBin('fixed', 45) self.bucket.setScale(1.3500000000000001) self.bucket.stash() self.missPatch = NodePath('dummy') self.missPatchAsset = self.model.find('**/miss') self.missPatchAsset.reparentTo(self.missPatch) self.missPatch.reparentTo(self) self.missPatch.setScale(1.1000000000000001) self.missPatch.stash() self.missSeq = None index = 1 while True: locator = self.model.find('**/locator_%i' % index) if locator.isEmpty(): break self.locators.append(locator) index += 1
def createDiner(self, i): diner = Suit.Suit() diner.dna = SuitDNA.SuitDNA() level = self.dinerInfo[i][2] level -= 4 diner.dna.newSuitRandom(level=level, dept='c') dept = self.dinerInfo[i][3][i] diner.dna.newSuitRandom(level=level, dept=dept) diner.setDNA(diner.dna) if self.useNewAnimations: diner.loop('sit', fromFrame=i) else: diner.pose('landing', 0) locator = self.tableGroup.find('**/chair_%d' % (i + 1)) locatorScale = locator.getNetTransform().getScale()[0] correctHeadingNp = locator.attachNewNode('correctHeading') self.chairLocators[i] = correctHeadingNp heading = self.rotationsPerSeatIndex[i] correctHeadingNp.setH(heading) sitLocator = correctHeadingNp.attachNewNode('sitLocator') base.sitLocator = sitLocator pos = correctHeadingNp.getPos(render) if SuitDNA.getSuitBodyType(diner.dna.name) == 'c': sitLocator.setPos(0.5, 3.65, -3.75) else: sitLocator.setZ(-2.4) sitLocator.setY(2.5) sitLocator.setX(0.5) self.sitLocators[i] = sitLocator diner.setScale(1.0 / locatorScale) diner.reparentTo(sitLocator) newLoc = NodePath('serviceLoc-%d-%d' % (self.index, i)) newLoc.reparentTo(correctHeadingNp) newLoc.setPos(0, 3.0, 1) self.serviceLocs[i] = newLoc base.serviceLoc = newLoc head = diner.find('**/joint_head') newIndicator = DinerStatusIndicator.DinerStatusIndicator(parent=head, pos=Point3( 0, 0, 3.5), scale=5.0) newIndicator.wrtReparentTo(diner) self.dinerStatusIndicators[i] = newIndicator # remove nametag (rip lag) diner.nametag3d.stash() diner.nametag.destroy() return diner
def startBallPlayback(self, power, angle, sequenceNum): flyBall = self.ballModel.copyTo(NodePath()) flyBall.setScale(1.0) flyBallBubble = self.getFlyBallBubble().instanceTo(NodePath()) flyBallBubble.reparentTo(flyBall) flyBall.setTag('pieSequence', str(sequenceNum)) flyBall.setTag('throwerId', str(self.avId)) t = power / 100.0 t = 1.0 - t dist = 300 - 200 * t time = 1.5 + 0.5 * t proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time) relVel = proj.startVel def getVelocity(root = self.root, relVel = relVel): return render.getRelativeVector(root, relVel) fly = Sequence(Func(flyBall.reparentTo, render), Func(flyBall.setPosHpr, self.root, 0, 0, 0, 0, 0, 0), Func(base.cTrav.addCollider, flyBallBubble, self.flyBallHandler), ProjectileInterval(flyBall, startVel=getVelocity, duration=3), Func(flyBall.detachNode), Func(base.cTrav.removeCollider, flyBallBubble), Func(self.notify.debug, 'removed collider'), Func(self.flyBallFinishedFlying, sequenceNum)) flyWithSound = Parallel(fly, SoundInterval(self.hitBallSfx, node=self.root), name='flyWithSound') self.notify.debug('starting flyball track') flyWithSound.start() self.flyBallTracks[sequenceNum] = flyWithSound return
def __init__(self, worldNode, holiday, zone): MinimapObject.__init__(self, 'capturePoint-%d' % zone, worldNode, NodePath('capturePoint')) self.holidayId = holiday self.zone = zone self.hpMeter = None self.barricadeIcon = None self.barricadeDestroyed = None self.blinker = None self.sentRemove = False self.hp = 0 self.maxHp = 0 whiteColor = (1.0, 1.0, 1.0, 1.0) self.blinker = Sequence(Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor), Wait(0.2), Func(self.setBarColor, whiteColor), Wait(0.2), Func(self.setBarColor)) return
def announceGenerate(self): DistributedObject.DistributedObject.announceGenerate(self) self.sendUpdate('avIdEnteredParty', [base.localAvatar.doId]) globalClock.syncFrameTime() self.startPartyClock() base.localAvatar.chatMgr.chatInputSpeedChat.addInsidePartiesMenu() self.spawnTitleText() messenger.send(self.generatedEvent) if config.GetBool('show-debug-party-grid', 0): self.testGrid = NodePath('test_grid') self.testGrid.reparentTo(base.cr.playGame.hood.loader.geom) for i in range(len(self.grid)): for j in range(len(self.grid[i])): cm = CardMaker('gridsquare') np = NodePath(cm.generate()) np.setScale(12) np.setP(-90.0) np.setPos(PartyUtils.convertDistanceFromPartyGrid(j, 0) - 6.0, PartyUtils.convertDistanceFromPartyGrid(i, 1) - 6.0, 0.1) np.reparentTo(self.testGrid) if self.grid[i][j]: np.setColorScale(0.0, 1.0, 0.0, 1.0) else: np.setColorScale(1.0, 0.0, 0.0, 1.0)
def __init__(self, cr): DistributedLawnDecor.DistributedLawnDecor.__init__(self, cr) #self.defaultModel = "phase_8/models/props/flower_treasure.bam" self.plantPath = NodePath('plantPath') self.plantPath.reparentTo(self) self.plotScale = 1.0 self.plantingGuiDoneEvent = "plantingGuiDone" self.toonStatueSelectionDoneEvent = "toonStatueSelectionDone" self.defaultModel = "phase_5.5/models/estate/dirt_mound" self.colorScaler = Vec4(1, 1, 1, 1) self.plantingGui = None
def loadCloud(self, version, radius, zOffset): self.notify.debug('loadOnePlatform version=%d' % version) cloud = NodePath('cloud-%d%d' % (radius, version)) cloudModel = loader.loadModel('phase_5.5/models/estate/bumper_cloud') cc = cloudModel.copyTo(cloud) colCube = cc.find('**/collision') colCube.setName('cloudSphere-0') dTheta = 2.0 * math.pi / self.numClouds cloud.reparentTo(self.cloudOrigin) axes = [Vec3(1, 0, 0), Vec3(0, 1, 0), Vec3(0, 0, 1)] cloud.setPos(radius * math.cos(version * dTheta), radius * math.sin(version * dTheta), 4 * random.random() + zOffset) cloud.setScale(4.0) cloud.setTag('number', '%d%d' % (radius, version)) self.clouds.append([cloud, random.choice(axes)])
def __init__(self, carNode): self.ticks = 0 self.endOfLife = False self.subExplosions = [] self.carNode = carNode self.containerNode = NodePath("CarExplosion") self.containerNode.reparentTo(carNode) self.containerNode.setPos(0.0, 0.0, 0.0) subExplosion = CarSubExplosion(-30, 0.3, 0, 0, self.containerNode) self.subExplosions.append(subExplosion) for i in range(6): self.addSubExplosion()
def __init__(self, serialNum, model, level, parent): self.serialNum = serialNum self._model = model self._level = level self._root = NodePath('Quadrant' + ` 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 renderQuadInto(self, mul=1, div=1, align=1, depthtex=None, colortex=None, auxtex0=None, auxtex1=None): """ Creates an offscreen buffer for an intermediate computation. Installs a quad into the buffer. Returns the fullscreen quad. The size of the buffer is initially equal to the size of the main window. The parameters 'mul', 'div', and 'align' can be used to adjust that size. """ texgroup = (depthtex, colortex, auxtex0, auxtex1) winx, winy = self.getScaledSize(mul, div, align) depthbits = bool(depthtex != None) buffer = self.createBuffer("filter-stage", winx, winy, texgroup, depthbits) if (buffer == None): return None cm = CardMaker("filter-stage-quad") cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setColor(Vec4(1,0.5,0.5,1)) quadcamnode = Camera("filter-quad-cam") lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) dr = buffer.makeDisplayRegion((0, 1, 0, 1)) dr.disableClears() dr.setCamera(quadcam) dr.setActive(True) dr.setScissorEnabled(False) # This clear stage is important if the buffer is padded, so that # any pixels accidentally sampled in the padded region won't # be reading from unititialised memory. buffer.setClearColor((0, 0, 0, 1)) buffer.setClearColorActive(True) self.buffers.append(buffer) self.sizes.append((mul, div, align)) return quad
def __init__(self, cameraNP): self.cameraNP = cameraNP self.id = CameraManager.nextID CameraManager.nextID += 1 self.otherNP = render self.lookAtNP = NodePath("CameraManager%d.lookAtNP" % self.id) self.lookAtEnabled = False self.targetPos = Point3(0.0, 0.0, 0.0) self.targetLookAtPos = Point3(0.0, 1.0, 0.0) self.enabled = False self.rate = 10.0
def loadAssets(self): self.beltModel = NodePath('beltModel') self.beltModel.reparentTo(self.boss.geom) self.startLocator = self.boss.geom.find('**/conveyer_belt_start_%d' % (self.index + 1)) self.endLocator = self.boss.geom.find('**/conveyer_belt_end_%d' % (self.index + 1)) center = (self.startLocator.getPos() + self.endLocator.getPos()) / 2.0 self.beltHeight = center.getZ() self.beltHeight += 0.10000000000000001 center.setZ(0) self.beltLength = (self.endLocator.getPos() - self.startLocator.getPos()).length() self.distBetweenFoodNodes = self.beltLength / self.NumFoodNodes self.notify.debug('setting beltModelPos to %s' % center) self.beltModel.setPos(center) self.setupFoodNodes() self.setupFoodIvals() self.setupToonupIvals() if self.index == 0: self.beltActorModel = loader.loadModel( 'phase_12/models/bossbotHQ/food_belt1_model') else: self.beltActorModel = loader.loadModel( 'phase_12/models/bossbotHQ/food_belt2_model') if self.beltActorModel: self.beltActor = Actor.Actor(self.beltActorModel) if self.index == 0: self.beltActor.loadAnims( {'idle': 'phase_12/models/bossbotHQ/food_belt1'}) else: self.beltActor.loadAnims( {'idle': 'phase_12/models/bossbotHQ/food_belt2'}) self.beltActor.reparentTo(render) self.beltActor.setPlayRate(self.BeltActorPlayRate, 'idle') mesh = self.beltActor.find('**/mesh_tide1') joint = self.beltActor.find('**/uvj_WakeWhiteTide1') mesh.setTexProjector(mesh.findTextureStage('default'), joint, self.beltActor) self.beltActor.setPos(self.startLocator.getPos()) self.beltSound = base.loadSfx( 'phase_12/audio/sfx/CHQ_FACT_conveyor_belt.wav') self.beltSound.setLoop(1) self.beltSoundInterval = SoundInterval(self.beltSound, node=self.beltModel, listenerNode=base.localAvatar, seamlessLoop=True, volume=0.25, cutOff=100)
def __init__(self, actor): """Initialise the camera, setting it to follow 'actor'. Arguments: actor -- The Actor that the camera will initially follow. """ self.actor = actor self.prevtime = 0 # The camera's controls: # "left" = move the camera left, 0 = off, 1 = on # "right" = move the camera right, 0 = off, 1 = on self.controlMap = {"left": 0, "right": 0} taskMgr.add(self.move, "cameraMoveTask") # Create a "floater" object. It is used to orient the camera above the # target actor's head. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(render) # Set up the camera. base.disableMouse() base.camera.setPos(self.actor.getX(), self.actor.getY() + 2, 2) # uncomment for topdown #base.camera.setPos(self.actor.getX(),self.actor.getY()+10,2) #base.camera.setHpr(180, -50, 0) # A CollisionRay beginning above the camera and going down toward the # ground is used to detect camera collisions and the height of the # camera above the ground. A ray may hit the terrain, or it may hit a # rock or a tree. If it hits the terrain, we detect the camera's # height. If it hits anything else, the camera is in an illegal # position. self.cTrav = CollisionTraverser() self.groundRay = CollisionRay() self.groundRay.setOrigin(0, 0, 1000) self.groundRay.setDirection(0, 0, -1) self.groundCol = CollisionNode('camRay') self.groundCol.addSolid(self.groundRay) self.groundCol.setFromCollideMask(BitMask32.bit(1)) self.groundCol.setIntoCollideMask(BitMask32.allOff()) self.groundColNp = base.camera.attachNewNode(self.groundCol) self.groundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.groundColNp, self.groundHandler)
def loadGrass(self): self.grassRoot = NodePath("GrassRoot") self.grassRoot.reparentTo(base.cr.playGame.hood.loader.geom) grass = loader.loadModel("phase_13/models/parties/grass") clearPositions = self.getClearSquarePositions() # Create up to 3 tufts of grass per clear square (avg) or up to PartyGlobals.TuftsOfGrass. numTufts = min(len(clearPositions) * 3, PartyGlobals.TuftsOfGrass) for i in range(numTufts): g = grass.copyTo(self.grassRoot) pos = random.choice(clearPositions) g.setPos(pos[0]+random.randint(-8,8), pos[1]+random.randint(-8,8), 0.0)
def load(self): self.root = NodePath('PartyCog-%d' % self.id) self.root.reparentTo(self.parentNode) path = 'phase_13/models/parties/cogPinata_' self.actor = Actor(path + 'actor', {'idle': path + 'idle_anim', 'down': path + 'down_anim', 'up': path + 'up_anim', 'bodyHitBack': path + 'bodyHitBack_anim', 'bodyHitFront': path + 'bodyHitFront_anim', 'headHitBack': path + 'headHitBack_anim', 'headHitFront': path + 'headHitFront_anim'}) self.actor.reparentTo(self.root) self.temp_transform = Mat4() self.head_locator = self.actor.attachNewNode('temphead') self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75) self.bodyColl.setTangible(1) self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' % self.id) self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.bodyCollNode.addSolid(self.bodyColl) self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode) self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5) self.headColl.setTangible(1) self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' % self.id) self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask) self.headCollNode.addSolid(self.headColl) self.headCollNodePath = self.root.attachNewNode(self.headCollNode) self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0) self.arm1Coll.setTangible(1) self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' % self.id) self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm1CollNode.addSolid(self.arm1Coll) self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode) self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0) self.arm2Coll.setTangible(1) self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' % self.id) self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask) self.arm2CollNode.addSolid(self.arm2Coll) self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode) splatName = 'splat-creampie' self.splat = globalPropPool.getProp(splatName) self.splat.setBillboardPointEye() self.splatType = globalPropPool.getPropType(splatName) self.pieHitSound = globalBattleSoundCache.getSound('AA_wholepie_only.ogg') self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg') self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole') self.hole.setTransparency(True) self.hole.setP(-90.0) self.hole.setScale(3) self.hole.setBin('ground', 3) self.hole.reparentTo(self.parentNode)
def makeArc(angleDegrees=360, numSteps=16, color=Vec4(1, 1, 1, 1)): ls = LineSegs() angleRadians = deg2Rad(angleDegrees) for i in range(numSteps + 1): a = angleRadians * i / numSteps y = math.sin(a) x = math.cos(a) ls.drawTo(x, y, 0) node = ls.create() if color != Vec4(1, 1, 1, 1): for i in range(numSteps + 1): ls.setVertexColor(i, color) pass return NodePath(node)
def setupFoodNodes(self): for i in xrange(self.NumFoodNodes): newPosIndex = self.NumFoodNodes - 1 - i yPos = -(self.beltLength / 2.0) + newPosIndex * self.distBetweenFoodNodes newFoodNode = NodePath('foodNode-%d-%d' % (self.index, i)) newFoodNode.reparentTo(self.beltModel) newFoodNode.setPos(0, yPos, self.beltHeight) debugFood = None if debugFood: debugFood.setScale(0.1) debugFood.reparentTo(newFoodNode) newFoodNode.setH(180) self.foodNodes.append(newFoodNode)
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 setupWheel(): global wheel model = loader.loadModel('models/shipparts/pir_m_shp_prt_wheel') wheel = NodePath('wheelRoot') r = model.find('**/+LODNode') r.flattenStrong() collisions = model.find('**/collisions') high = r.find('**/lod_high') med = r.find('**/lod_med') low = r.find('**/lod_low') high.reparentTo(wheel.attachNewNode(ModelNode('high'))) med.reparentTo(wheel.attachNewNode(ModelNode('med'))) low.reparentTo(wheel.attachNewNode(ModelNode('low'))) collisions.reparentTo(wheel)
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)
def __init__(self, parent, system, **kwargs): super(StarSystemView, self).__init__(parent, system, **kwargs) self.refscale = 100 self.node = NodePath('system') planets, stars = [self.obj.planets, self.obj.stars] starview = StarView(self, system.star) starview.node.setScale(self.refscale) self.starview = starview # Calculate the smallest distance between any two objects so # we can ensure no overlaps even in the worst-case scenarios. last_apsis = 0 min_dist = float("inf") for planet in self.obj.planets: dist = planet.apsis - last_apsis if dist < min_dist: min_dist = dist last_apsis = planet.apsis scalefactor = system.star.radius / system.star.radius_km scalefactor *= (min_dist * 1.2) / last_apsis scalefactor *= self.refscale / 2 self.scalefactor = scalefactor min_radius = min([obj.radius for obj in planets + stars]) max_radius = max([obj.radius for obj in planets + stars]) self.planet_views = [] for planet in planets: pview = PlanetView(self, planet) pview.set_light(starview.light) pview.node.setScale(self.refscale * log(planet.radius_km) / log(system.star.radius_km)) self.planet_views.append(pview) self.update_orbits() self.ship_views = {} for ship in self.obj.ships: self.add_ship(ship) #cm = CardMaker('card') #radius = last_apsis*AU*scalefactor #cm.setFrame(-radius, radius, -radius, radius) #trail = self.node.attachNewNode(cm.generate()) #trail.setP(90) #trail.setTwoSided(True) self.node.reparentTo(self.parent.node)