def initSwitches(self): # Find switch armatures objects = self.level.findAllMatches('**/Switch') # Load switch anim switchAnimNode = loader.loadModel("Switch-Activate.egg") switchAnim = switchAnimNode.find("+AnimBundleNode").node().getBundle() self.switchControls = {} i = 0 for object in objects: bundle = object.node().getBundle(0) control = bundle.bindAnim(switchAnim, ~0) switchsphere = CollisionSphere(0, 0, 0, 0.5) switchsphere.setTangible(False) switchColNP = object.getParent().attachNewNode(CollisionNode('switchActivation%d'%i)) switchColNP.node().addSolid(switchsphere) self.switchControls.setdefault(object.getParent(), [control, switchColNP]) switchName = object.getParent().getParent().getName() self.accept("playerCollision-in-switchActivation%d"%i, self.__setActivateElement, extraArgs=[True, switchName, "switch"]) self.accept("playerCollision-out-switchActivation%d"%i, self.__setActivateElement, extraArgs=[False, switchName, "switch"]) i+=1 for key, value in self.switchControls.iteritems(): value[0].pose(0)
def setupCollisions(self): sphere = CollisionSphere(0, 0, 0, 2) sphere.setTangible(0) node = CollisionNode(self.collisionName) node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) self.collisionNode = self.attachNewNode(node)
def loadAttack(self): self.phone = loader.loadModel('phase_3.5/models/props/phone.bam') self.phone.setHpr(0, 0, 180) if self.suit.type == 'B': self.phone.setPos(0.7, 0.15, 0) elif self.suit.type == 'C': self.phone.setPos(0.25, 0, 0) self.receiver = loader.loadModel('phase_3.5/models/props/receiver.bam') self.receiver.reparentTo(self.phone) self.cord = Rope() self.cord.ropeNode.setUseVertexColor(1) self.cord.ropeNode.setUseVertexThickness(1) self.cord.setup(3, ({'node': self.phone, 'point': (0.8, 0, 0.2), 'color': (0, 0, 0, 1), 'thickness': 1000}, {'node': self.phone, 'point': (2, 0, 0), 'color': (0, 0, 0, 1), 'thickness': 1000}, {'node': self.receiver, 'point': (1.1, 0.25, 0.5), 'color': (0, 0, 0, 1), 'thickness': 1000}), []) self.cord.setH(180) self.phoneSfx = base.audio3d.loadSfx('phase_3.5/audio/sfx/SA_hangup.mp3') base.audio3d.attachSoundToObject(self.phoneSfx, self.phone) self.hangupSfx = base.audio3d.loadSfx('phase_3.5/audio/sfx/SA_hangup_place_down.mp3') base.audio3d.attachSoundToObject(self.hangupSfx, self.phone) collSphere = CollisionSphere(0, 0, 0, 2) collSphere.setTangible(0) collNode = CollisionNode('phone_shootout') collNode.addSolid(collSphere) collNode.setCollideMask(CIGlobals.WallBitmask) self.collNP = self.phone.attachNewNode(collNode)
def initChests(self): objects = self.level.findAllMatches('**/Box_long_looseLid') boxAnimNode = loader.loadModel("Box_long_looseLid-open.egg") boxAnim = boxAnimNode.find("+AnimBundleNode").node().getBundle() self.boxControls = {} i = 0 for object in objects: bundle = object.node().getBundle(0) control = bundle.bindAnim(boxAnim, ~0) boxsphere = CollisionSphere(0, 0, 0, 1.0) boxsphere.setTangible(False) boxColNP = object.getParent().attachNewNode(CollisionNode('boxActivation%d'%i)) boxColNP.node().addSolid(boxsphere) #boxColNP.show() self.boxControls.setdefault(object.getParent(), [control, boxColNP]) boxName = object.getParent().getParent().getName() self.accept("playerCollision-in-boxActivation%d"%i, self.__setActivateElement, extraArgs=[True, boxName, "box"]) self.accept("playerCollision-out-boxActivation%d"%i, self.__setActivateElement, extraArgs=[False, boxName, "box"]) i+=1
def load(self): spawn = random.choice(DGG.SpawnPoints) base.localAvatar.setPos(spawn) base.localAvatar.setHpr(0, 0, 0) self.soundPickUpBarrel = base.loadSfx("phase_6/audio/sfx/SZ_MM_gliss.mp3") self.soundDropOff = base.loadSfx("phase_4/audio/sfx/MG_sfx_travel_game_bell_for_trolley.mp3") self.setMinigameMusic("phase_4/audio/bgm/MG_Delivery.mp3") self.setDescription( "A new supply of Gags were just shipped to Toontown! " + "Run over to a truck with Gag barrels to take a barrel out. Then, carry it over to the Gag Shop. " + "Try to unload and deliver as many barrels as you can to the Gag Shop. " + "Watch out for the Cogs - they might try to snatch a barrel!" ) self.setWinnerPrize(100) self.setLoserPrize(0) self.gagShop = loader.loadModel("phase_4/models/modules/gagShop_TT.bam") self.gagShop.reparentTo(base.render) self.gagShop.setY(-70) sphere = CollisionSphere(0, 0, 0, 3) sphere.setTangible(0) node = CollisionNode("MGDeliveryGagShop") node.addSolid(sphere) self.gagShopCollNP = self.gagShop.attachNewNode(node) self.world = loader.loadModel("phase_4/models/minigames/delivery_area.egg") self.world.setY(-5) self.world.reparentTo(base.render) self.sky = loader.loadModel("phase_3.5/models/props/TT_sky.bam") self.sky.reparentTo(base.camera) ce = CompassEffect.make(NodePath(), CompassEffect.PRot | CompassEffect.PZ) self.sky.node().setEffect(ce) self.sky.setZ(-20) self.skyUtil.startSky(self.sky) base.camera.setPos(20, 50, 30) base.camera.lookAt(20, 0, 7.5) DistributedMinigame.load(self)
def announceGenerate(self): DistributedNode.announceGenerate(self) self.kart = loader.loadModel('phase_6/models/karting/Kart3_Final.bam') self.kart.find('**/decals').removeNode() self.kart.reparentTo(self) self.pod = loader.loadModel('phase_4/models/minigames/pods_truck.egg') self.pod.reparentTo(self) self.pod.setScale(0.2) self.pod.setY(8.5) self.pod.setH(180) self.rope = Rope() self.rope.ropeNode.setUseVertexColor(1) self.rope.setup(3, ({'node': self.kart, 'point': (0, 1.5, 0.7), 'color': (0, 0, 0, 1), 'thickness': 1000}, {'node': self.kart, 'point': (0, 1.5, 0.7), 'color': (0, 0, 0, 1), 'thickness': 1000}, {'node': self.pod, 'point': (0, 31, 5), 'color': (0, 0, 0, 1), 'thickness': 1000}), []) self.rope.setH(180) self.rope.reparentTo(self) sphere = CollisionSphere(0, 0, 0, 2) sphere.setTangible(0) node = CollisionNode(self.uniqueName('truck_trigger')) node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) self.triggerNP = self.attachNewNode(node) self.triggerNP.setPos(0, 8.0, 2.0) self.setScale(2.0) self.accept('enter' + self.triggerNP.node().getName(), self.__handleTruckTrigger)
def doAttack(self, particlePaths, track_name, particleCollId, animation_name, delayUntilRelease, animationSpeed = 1, handObjPath = None, handObjParent = None, startRightAway = True, ts = 0): for path in particlePaths: particle = ParticleLoader.loadParticleEffect(path) self.particles.append(particle) sphere = CollisionSphere(0, 0, 0, 1) sphere.setTangible(0) node = CollisionNode(particleCollId) node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) self.targetX = self.attacksClass.target.getX(render) self.targetY = self.attacksClass.target.getY(render) self.targetZ = self.attacksClass.target.getZ(render) if len(self.particles) == 1: self.shootOutCollNP = self.particles[0].attachNewNode(node) else: self.shootOutCollNP = self.suit.attachNewNode(node) if handObjPath and handObjParent: self.handObj = loader.loadModel(handObjPath) self.handObj.reparentTo(handObjParent) self.suit.setPlayRate(animationSpeed, animation_name) self.suit.play(animation_name) if hasattr(self.suit, 'uniqueName'): track_name = self.suit.uniqueName(track_name) particleCollId = self.suit.uniqueName(particleCollId) self.suitTrack = Sequence(name=track_name) self.suitTrack.append(Wait(delayUntilRelease)) self.suitTrack.append(Func(self.releaseAttack)) self.suitTrack.append(Wait(self.particleIvalDur)) self.suitTrack.setDoneEvent(self.suitTrack.getName()) self.acceptOnce(self.suitTrack.getDoneEvent(), self.finishedAttack) if startRightAway: self.suitTrack.start(ts)
def __setupCollisions(self): sphere = CollisionSphere(0, 0, 0, 4) sphere.setTangible(0) collisionNode = CollisionNode(self.uniqueName('NPCToonSphere')) collisionNode.addSolid(sphere) collisionNode.setCollideMask(CIGlobals.WallBitmask) self.collisionNodePath = self.attachNewNode(collisionNode) self.collisionNodePath.setY(1.5)
def getSprayTrack(self, origin, target, scaleUp, hold, scaleDown, horizScale = 1.0, vertScale = 1.0): base.localAvatar.stop(self.toonAnim) self.lastFrame = self.avatar.getCurrentFrame(self.toonAnim) track = Sequence() sprayProp = loader.loadModel(GagGlobals.SPRAY_MDL) sprayProp.setTwoSided(1) sprayScale = hidden.attachNewNode('spray-parent') sprayRot = hidden.attachNewNode('spray-rotate') sprayRot.setColor(GagGlobals.WATER_SPRAY_COLOR) sprayRot.setTransparency(1) collNode = CollisionNode('Collision') spraySphere = CollisionSphere(0, 0, 0, 1) spraySphere.setTangible(0) collNode.addSolid(spraySphere) collNode.setCollideMask(CIGlobals.WallBitmask) sprayNP = sprayRot.attachNewNode(collNode) sprayNP.setY(1) self.sprayNP = sprayNP event = CollisionHandlerEvent() event.set_in_pattern('%fn-into') event.set_out_pattern('%fn-out') base.cTrav.add_collider(sprayNP, event) self.avatar.acceptOnce(sprayNP.node().getName() + '-into', self.onCollision) def showSpray(sprayScale, sprayProp, origin, target): objects = [sprayRot, sprayScale, sprayProp] for item in objects: index = objects.index(item) if index == 0: item.reparentTo(self.sprayJoint) item.setPos(self.sprayJoint.getPos(render)) item.setHpr(self.sprayJoint.getHpr(render)) item.setP(0) else: item.reparentTo(objects[index - 1]) item.clearMat() track.append(Func(showSpray, sprayScale, sprayProp, origin, target)) self.spray = sprayRot def calcTargetScale(): distance = Vec3(target - origin).length() yScale = distance / GagGlobals.SPRAY_LEN targetScale = Point3(yScale * horizScale, yScale, yScale * vertScale) return targetScale track.append(Parallel(LerpScaleInterval(sprayScale, scaleUp, calcTargetScale, startScale=GagGlobals.PNT3NEAR0), sprayNP.posInterval(0.25, self.spray.getPos(render) + Point3(0, 50, 0), startPos=self.spray.getPos(render) + Point3(0, 5, 0)))) track.append(Wait(hold)) track.append(Func(self.handleMiss)) track.append(LerpScaleInterval(sprayScale, 0.75, GagGlobals.PNT3NEAR0)) def hideSpray(): (lambda prop: prop.removeNode(), [sprayProp, sprayRot, sprayScale]) track.append(Func(hideSpray)) track.append(Func(self.completeSquirt)) return track
def __initializeEventSphere(self): sphere = CollisionSphere(0, 0, 0, 2) sphere.setTangible(0) node = CollisionNode(self.uniqueName('DEagleSuit-eventSphere')) node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) np = self.attachNewNode(node) np.setSz(2.5) np.setZ(5.5) self.eventSphereNodePath = np
def __initCollisions(self, name): self.notify.debug("Initializing collision sphere...") ss = CollisionSphere(0, 0, 0, 5) ss.setTangible(0) snode = CollisionNode(name) snode.add_solid(ss) snode.set_collide_mask(CIGlobals.WallBitmask) self.snp = self.attach_new_node(snode) self.snp.setZ(3) self.acceptOnce("enter" + self.snp.node().getName(), self.__handleEnterCollisionSphere)
def __initShopCollisions(self, colName): self.notify.debug('Setting up shop collisions') shopSphere = CollisionSphere(0, 0, 0, 5) shopSphere.setTangible(0) shopNode = CollisionNode(colName) shopNode.addSolid(shopSphere) shopNode.setCollideMask(CIGlobals.WallBitmask) self.shopNP = self.attachNewNode(shopNode) self.shopNP.setZ(3) self.acceptOnce('enter' + self.shopNP.node().getName(), self.__handleShopCollision)
def setupHeadSphere(self, avatarNodePath): collSphere = CollisionSphere(0, 0, 0, 1) collSphere.setTangible(1) collNode = CollisionNode('Flyer.cHeadCollSphere') collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask) collNode.setIntoCollideMask(BitMask32.allOff()) collNode.addSolid(collSphere) self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode) self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0) self.headCollisionEvent = CollisionHandlerEvent() self.headCollisionEvent.addInPattern('%fn-enter-%in') self.headCollisionEvent.addOutPattern('%fn-exit-%in') base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
def setupEventSphere(self, bitmask, avatarRadius): self.avatarRadius = avatarRadius cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04) cSphere.setTangible(0) cSphereNode = CollisionNode('Flyer.cEventSphereNode') cSphereNode.addSolid(cSphere) cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode) cSphereNode.setFromCollideMask(bitmask) cSphereNode.setIntoCollideMask(BitMask32.allOff()) self.event = CollisionHandlerEvent() self.event.addInPattern('enter%in') self.event.addOutPattern('exit%in') self.cEventSphereNodePath = cSphereNodePath
def __initCollisions(self, name): self.notify.debug('Initializing collision sphere...') numSlots = len(self.circles) ss = CollisionSphere(0, 0, 0, self.numPlayers2SphereRadius[numSlots]) ss.setTangible(0) snode = CollisionNode(name) snode.add_solid(ss) snode.set_collide_mask(CIGlobals.WallBitmask) self.snp = self.attach_new_node(snode) self.snp.setZ(3) self.snp.setY(self.numPlayers2SphereY[numSlots]) self.snp.setSx(self.numPlayers2SphereSx[numSlots]) self.snp.setSy(self.numPlayers2SphereSy[numSlots]) self.acceptOnce('enter' + self.snp.node().getName(), self.__handleEnterCollisionSphere)
def buildProjCollisions(self): gagSph = CollisionSphere(0, 0, 0, 1) gagSph.setTangible(0) gagNode = CollisionNode('projSensor') gagNode.addSolid(gagSph) gagNP = self.gag.attach_new_node(gagNode) gagNP.setScale(0.75, 0.8, 0.75) gagNP.setPos(0.0, 0.1, 0.5) gagNP.setCollideMask(BitMask32.bit(0)) gagNP.node().setFromCollideMask(CIGlobals.FloorBitmask) event = CollisionHandlerEvent() event.set_in_pattern('%fn-into') event.set_out_pattern('%fn-out') base.cTrav.addCollider(gagNP, event)
def loadCollision(self): collTube = CollisionTube(0.0, 0.0, 0.0, 0.0, 0.0, 6.0, 5.4) collTube.setTangible(True) self.trampolineCollision = CollisionNode(self.uniqueName('TrampolineCollision')) self.trampolineCollision.addSolid(collTube) self.trampolineCollision.setCollideMask(OTPGlobals.CameraBitmask | OTPGlobals.WallBitmask) self.trampolineCollisionNP = self.tramp.attachNewNode(self.trampolineCollision) collSphere = CollisionSphere(0.0, 0.0, 0.0, 7.0) collSphere.setTangible(False) self.trampolineTrigger = CollisionNode(self.uniqueName('TrampolineTrigger')) self.trampolineTrigger.addSolid(collSphere) self.trampolineTrigger.setIntoCollideMask(OTPGlobals.WallBitmask) self.trampolineTriggerNP = self.tramp.attachNewNode(self.trampolineTrigger) self.accept('enter%s' % self.uniqueName('TrampolineTrigger'), self.onTrampolineTrigger)
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 setPickCollisions(self, value): if value: print "setting pick collisions" b = self.node.getBounds().getRadius() self.pickCTrav = CollisionTraverser() self.pickCollisionTube = CollisionSphere(b/2,0,b/2,0.035*self.properties['hitboxscale']+0.01) self.pickCollisionNode = CollisionNode('characterPickTube') self.pickCollisionNode.addSolid(self.pickCollisionTube) self.pickCollisionNodeNp = NodePath(self.pickCollisionNode) self.pickCollisionNodeNp.reparentTo(self.node) self.pickCollisionHandler = CollisionHandlerQueue() self.pickCTrav.addCollider(self.pickCollisionNodeNp, self.pickCollisionHandler) if self.showCollisions == True: # Uncomment this line to see the collision rays self.pickCollisionNodeNp.show() # Uncomment this line to show a visual representation of the # collisions occuring self.pickCTrav.showCollisions(render) else: #dereferincing all pick colliders (must be done in order not to collide onto NPCs) self.pickCTrav = None self.pickCollisionTube = None self.pickCollisionNode = None self.pickCollisionNodeNp = None self.pickCollisionHandler = None
def create_ball_coll(self, ball_actor): # Build a collisionNode for this smiley which is a sphere of the same diameter as the model ball_coll_node = ball_actor.attachNewNode(CollisionNode('ball_cnode')) ball_coll_sphere = CollisionSphere(0, 0, 0, 1) ball_coll_node.node().addSolid(ball_coll_sphere) # Watch for collisions with our brothers, so we'll push out of each other ball_coll_node.node().setIntoCollideMask(BitMask32().bit( self.ball_bit)) # we're only interested in colliding with the ground and other smileys cMask = BitMask32() cMask.setBit(self.ground_bit) cMask.setBit(self.ball_bit) ball_coll_node.node().setFromCollideMask(cMask) # Now, to keep the spheres out of the ground plane and each other, let's attach a physics handler to them ball_handler = PhysicsCollisionHandler() # Set the physics handler to manipulate the smiley actor's transform. ball_handler.addCollider(ball_coll_node, ball_actor) # This call adds the physics handler to the traverser list # (not related to last call to addCollider!) self.base.cTrav.addCollider(ball_coll_node, ball_handler) # Now, let's set the collision handler so that it will also do a CollisionHandlerEvent callback # But...wait? Aren't we using a PhysicsCollisionHandler? # The reason why we can get away with this is that all CollisionHandlerXs are inherited from # CollisionHandlerEvent, # so all the pattern-matching event handling works, too ball_handler.addInPattern('%fn-into-%in') return ball_coll_node
def __init__(self, id_, class_, class_data, model, y_positions, enemy_handler): EnemyUnit.__init__(self, id_, class_, class_data, model, y_positions, enemy_handler) if chance(50): taskMgr.doMethodLater( # noqa: F821 random.randint(26, 28), self._play_idle_anim, self.id + "_idle") self._cry_snd = base.sound_mgr.loadSfx( # noqa: F821 "sounds/combat/enemy_cry{num}.ogg".format( num=random.randint(1, 3))) self._cry_snd.setVolume(0.4) base.sound_mgr.attachSoundToObject(self._cry_snd, self.model) # noqa: F821 else: self._cry_snd = None taskMgr.doMethodLater( # noqa: F821 random.randint(27, 29), base.world.play_fight_music, # noqa: F821 "play_music", ) self._col_node = self._init_col_node(SHOT_RANGE_MASK, MOUSE_MASK, CollisionSphere(0, 0, 0.05, 0.05)) base.common_ctrl.traverser.addCollider( # noqa: F821 self._col_node, enemy_handler) self._explosion = base.effects_mgr.explosion(self) # noqa: F821
def setupElevatorKart(self): collisionRadius = ElevatorConstants.ElevatorData[ self.type]['collRadius'] self.elevatorSphere = CollisionSphere(0, 0, 0, collisionRadius) self.elevatorSphere.setTangible(1) self.elevatorSphereNode = CollisionNode( self.uniqueName('elevatorSphere')) self.elevatorSphereNode.setIntoCollideMask(ToontownGlobals.WallBitmask) self.elevatorSphereNode.addSolid(self.elevatorSphere) self.elevatorSphereNodePath = self.getElevatorModel().attachNewNode( self.elevatorSphereNode) self.elevatorSphereNodePath.hide() self.elevatorSphereNodePath.reparentTo(self.getElevatorModel()) self.elevatorSphereNodePath.stash() self.boardedAvIds = {} self.finishSetup()
def initCollisionSphere(obj, desc, radiusMultiplier, intoMask=BitMask32(0x1), isFromCollider=False): # Get the size of the object for the collision sphere. bounds = obj.getChild(0).getBounds() center = bounds.getCenter() radius = bounds.getRadius() * radiusMultiplier # Create a collision sphere and name it something understandable. collSphereStr = desc cNode = CollisionNode(collSphereStr) cNode.addSolid(CollisionSphere(center, radius)) if not isFromCollider: cNode.setFromCollideMask(BitMask32(0x0)) cNode.setIntoCollideMask(intoMask) cNodepath = obj.attachNewNode(cNode) # if show: #cNodepath.show() # Return a tuple with the collision node and its corrsponding string so # that the bitmask can be set. return cNodepath, collSphereStr
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()
def init_sensors(self, entity, movement): solids = movement.solids for tag, solid in solids.items(): if 'shape' in solid: # Create solids from specification solid['tag'] = tag if solid['shape'] is CollisionSphere: shape = CollisionSphere(solid['center'], solid['radius']) elif solid['shape'] is CollisionCapsule: shape = CollisionCapsule( solid['end_a'], solid['end_b'], solid['radius'], ) else: raise Exception("Shape unsupported.") self.add_shape(entity, movement, solid, shape) else: # Fetch solids from model model_node = self.proxies['character_node'].field(entity) solid_nodes = model_node.find_all_matches( f'**/{movement.node_name}', ) # FIXME: This is a temporary prevention of sing multiple # solids in one movement system. This whole .py needs to # be refactored to account for multiple ones. assert len(solids) == 1 solid_node = solid_nodes[0] solid_node.reparent_to(model_node) solid['node'] = solid_node solid_objects = solid_node.node().get_solids() # FIXME: As above, please refactor this .py to account # for multiple solids. assert len(solids) == 1 solid_object = solid_objects[0] solid['shape'] = solid_object.type if solid['shape'] == CollisionSphere: solid['center'] = solid_object.center solid['radius'] = solid_object.radius # FIXME: This is mostly copypasta from add_solid, which # should be broken up. node = solid_node.node() node.set_from_collide_mask(movement.from_collide_mask) node.set_into_collide_mask(movement.into_collide_mask) movement.traverser.add_collider( solid_node, movement.queue, ) node.set_python_tag(movement.tag_name, movement) if movement.debug: solid_node.show() if movement.debug: scene_proxy = self.proxies['scene_node'] scene = entity[scene_proxy.component_type] scene_node = scene_proxy.field(entity) movement.traverser.show_collisions(scene_node)
def initializeSmartCameraCollisions(self): if self.initialized: return self.ccTrav = CollisionTraverser('LocalAvatar.ccTrav') self.ccLine = CollisionSegment(0.0, 0.0, 0.0, 1.0, 0.0, 0.0) self.ccLineNode = CollisionNode('ccLineNode') self.ccLineNode.addSolid(self.ccLine) self.ccLineNodePath = base.localAvatar.attachNewNode(self.ccLineNode) self.ccLineBitMask = CIGlobals.CameraBitmask self.ccLineNode.setFromCollideMask(self.ccLineBitMask) self.ccLineNode.setIntoCollideMask(BitMask32.allOff()) self.camCollisionQueue = CollisionHandlerQueue() self.ccTrav.addCollider(self.ccLineNodePath, self.camCollisionQueue) self.ccSphere = CollisionSphere(0, 0, 0, 1) self.ccSphereNode = CollisionNode('ccSphereNode') self.ccSphereNode.addSolid(self.ccSphere) self.ccSphereNodePath = base.camera.attachNewNode(self.ccSphereNode) self.ccSphereNode.setFromCollideMask(CIGlobals.CameraBitmask) self.ccSphereNode.setIntoCollideMask(BitMask32.allOff()) self.camPusher = CollisionHandlerPusher() self.camPusher.addCollider(self.ccSphereNodePath, base.camera) self.camPusher.setCenter(base.localAvatar) self.ccPusherTrav = CollisionTraverser('LocalAvatar.ccPusherTrav') self.ccSphere2 = self.ccSphere self.ccSphereNode2 = CollisionNode('ccSphereNode2') self.ccSphereNode2.addSolid(self.ccSphere2) self.ccSphereNodePath2 = base.camera.attachNewNode(self.ccSphereNode2) self.ccSphereNode2.setFromCollideMask(CIGlobals.CameraBitmask) self.ccSphereNode2.setIntoCollideMask(BitMask32.allOff()) self.camPusher2 = CollisionHandlerPusher() self.ccPusherTrav.addCollider(self.ccSphereNodePath2, self.camPusher2) self.camPusher2.addCollider(self.ccSphereNodePath2, base.camera) self.camPusher2.setCenter(base.localAvatar) self.camFloorRayNode = base.localAvatar.attachNewNode('camFloorRayNode') self.ccRay = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0) self.ccRayNode = CollisionNode('ccRayNode') self.ccRayNode.addSolid(self.ccRay) self.ccRayNodePath = self.camFloorRayNode.attachNewNode(self.ccRayNode) self.ccRayBitMask = CIGlobals.FloorBitmask self.ccRayNode.setFromCollideMask(self.ccRayBitMask) self.ccRayNode.setIntoCollideMask(BitMask32.allOff()) self.ccTravFloor = CollisionTraverser('LocalAvatar.ccTravFloor') self.camFloorCollisionQueue = CollisionHandlerQueue() self.ccTravFloor.addCollider(self.ccRayNodePath, self.camFloorCollisionQueue) self.ccTravOnFloor = CollisionTraverser('LocalAvatar.ccTravOnFloor') self.ccRay2 = CollisionRay(0.0, 0.0, 0.0, 0.0, 0.0, -1.0) self.ccRay2Node = CollisionNode('ccRay2Node') self.ccRay2Node.addSolid(self.ccRay2) self.ccRay2NodePath = self.camFloorRayNode.attachNewNode(self.ccRay2Node) self.ccRay2BitMask = CIGlobals.FloorBitmask self.ccRay2Node.setFromCollideMask(self.ccRay2BitMask) self.ccRay2Node.setIntoCollideMask(BitMask32.allOff()) self.ccRay2MoveNodePath = hidden.attachNewNode('ccRay2MoveNode') self.camFloorCollisionBroadcaster = CollisionHandlerFloor() self.camFloorCollisionBroadcaster.setInPattern('on-floor') self.camFloorCollisionBroadcaster.setOutPattern('off-floor') self.camFloorCollisionBroadcaster.addCollider(self.ccRay2NodePath, self.ccRay2MoveNodePath) self.cTrav.addCollider(self.ccRay2NodePath, self.camFloorCollisionBroadcaster) self.initialized = True
def keyBindupdate(self, task): dt = globalClock.getDt() pos = self.player.getPos() if keyMap["left"]: pos.x -= self.speed * dt if self.angle > 45: self.angle -= 4 self.player.setH(self.angle) if not keyMap["left"]: if self.angle < 90: self.angle += 3 self.player.setH(self.angle) if keyMap["right"]: pos.x += self.speed * dt if self.angle < 135: self.angle += 4 self.player.setH(self.angle) if not keyMap["right"]: if self.angle > 90: self.angle -= 3 self.player.setH(self.angle) if keyMap["up"]: pos.z += self.speed * dt if keyMap["down"]: pos.z -= self.speed * dt if keyMap["weapon"]: self.projectile = self.loader.loadModel("models/misc/sphere") self.projectile.setScale(0.5, 0.5, 1) self.projectile.setPos(self.player.getPos()) self.projectile.reparentTo(self.render) self.playerProjectileColliderNode = CollisionNode( "player_projectile") self.playerProjectileColliderNode.addSolid( CollisionSphere(0.5, 0, 0.2, 1)) self.projectileCollider = self.projectile.attachNewNode( self.playerProjectileColliderNode) base.pusher.addCollider(self.projectileCollider, self.projectile) base.cTrav.addCollider(self.projectileCollider, self.pusher) # self.projectileCollider.show() self.trajectory = ProjectileInterval(self.projectile, duration=1, startPos=(pos.x - 1, pos.y + 3, pos.z), startVel=(0, 0, 115)) self.trajectory.start() keyMap["weapon"] = False self.player.setPos(pos) return task.cont
def initCollision(self): cNode = CollisionNode("{}_{}".format(self.name, self.indexNumber)) (x, y, z, s) = self.collision_size cNode.addSolid(CollisionSphere(x, y, z, s)) faCollision = self.actor.attachNewNode(cNode) base.pusher.addCollider( faCollision, self.actor, base.drive.node()) base.cTrav.addCollider(faCollision, base.pusher)
def buildCollisions(self): TrapGag.buildCollisions(self) gagSph = CollisionSphere(0, 0, 0, self.collRadius) gagSph.setTangible(0) gagNode = CollisionNode('gagSensor') gagNode.addSolid(gagSph) gagNP = self.gag.attachNewNode(gagNode) gagNP.setScale(0.75, 0.8, 0.75) gagNP.setPos(0.0, 0.1, 0.5) gagNP.setCollideMask(BitMask32.bit(0)) gagNP.node().setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask) event = CollisionHandlerEvent() event.set_in_pattern('%fn-into') event.set_out_pattern('%fn-out') base.cTrav.addCollider(gagNP, event) if self.isLocal(): self.avatar.accept('gagSensor-into', self.onCollision)
def buildCollisions(self): TrapGag.buildCollisions(self) gagSph = CollisionSphere(0, 0, 0, 1) gagSph.setTangible(0) gagNode = CollisionNode('gagSensor') gagNode.addSolid(gagSph) gagNP = self.entity.attachNewNode(gagNode) gagNP.setScale(0.75, 0.8, 0.75) gagNP.setPos(0.0, 0.1, 0.5) gagNP.setCollideMask(BitMask32.bit(0)) gagNP.node().setFromCollideMask(CIGlobals.FloorBitmask) event = CollisionHandlerEvent() event.setInPattern("%fn-into") event.setOutPattern("%fn-out") base.cTrav.addCollider(gagNP, event) self.avatar.acceptOnce('gagSensor-into', self.onCollision)
def _initCollisions(self): offset = Globals.WaterCoolerTriggerOffset self.collSphere = CollisionSphere(offset[0], offset[1], offset[2], Globals.WaterCoolerTriggerRadius) self.collSphere.setTangible(0) name = Globals.WaterCoolerCollisionName self.collNode = CollisionNode(name) self.collNode.addSolid(self.collSphere) self.collNodePath = self.attachNewNode(self.collNode)
def setupWallSphere(self): sphere = CollisionSphere(0.0, 0.0, 0.0, 3.0) node = CollisionNode('DistributedPieTurret.WallSphere') node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) self.wallCollNode = self.cannon.attachNewNode(node) self.wallCollNode.setZ(2) self.wallCollNode.setY(1.0)
def loadCollisions(self): sphere = CollisionSphere(0, 0, 0, 1) sphere.setTangible(0) node = CollisionNode('objectCollNode') node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) self.collSensorNodePath = self.attachNewNode(node) ray = CollisionRay(0.0, 0.0, CollisionHandlerRayStart, 0.0, 0.0, -1.0) rayNode = CollisionNode('objectRayNode') rayNode.addSolid(ray) rayNode.setFromCollideMask(CIGlobals.FloorBitmask) rayNode.setIntoCollideMask(BitMask32.allOff()) self.collRayNodePath = self.attachNewNode(rayNode) lifter = CollisionHandlerFloor() lifter.addCollider(self.collRayNodePath, self) base.cTrav.addCollider(self.collRayNodePath, lifter)
def getWrappedSphere(self): tightBounds = self.objectNP.getBounds() sphereCenter = tightBounds.getCenter() sphereRadius = tightBounds.getRadius() return CollisionSphere(sphereCenter, sphereRadius)
def __init__(self, entity): self.target = CollisionSphere(0, 0, 0, 1) self.target_node = CollisionNode('collision_entity') self.target_node.setFromCollideMask(0) # unused self.target_node.setIntoCollideMask(ENEMIES) self.target_nodepath = entity.model.attach_new_node(self.target_node) self.target_nodepath.node().addSolid(self.target) self.target_nodepath.show()
def __genbcn_manhattan(self, linklist, mothercn=None, radius=70.0, name="autogen"): """ gennerate the ball collision node for a link the balls are generated along the manhattan directions between joints :return: author: weiwei date: 20171101 """ radius = float(radius) balldist = radius if mothercn is None: mothercn = CollisionNode(name) for link, divdir in linklist: spos = link['linkpos'] epos = link['linkend'] # linkvec direction linkdir = np.dot((epos - spos), divdir) * divdir linkdirlength = np.linalg.norm(linkdir) if linkdirlength < 1e-4: continue linkdirnormalized = linkdir / linkdirlength nball = int(math.ceil(linkdirlength / balldist)) for i in range(0, nball): pos = spos + linkdirnormalized * i * (balldist) colsphere = CollisionSphere(pos[0], pos[1], pos[2], radius) mothercn.addSolid(colsphere) # linkvec orthogonal direction linkorth = epos - spos - linkdir linkorthlength = np.linalg.norm(linkorth) if linkorthlength < 1e-4: continue linkorthnormalized = linkorth / linkorthlength nball = int(math.ceil(linkorthlength / balldist)) for i in range(0, nball): pos = spos + linkdir + linkorthnormalized * i * (balldist) colsphere = CollisionSphere(pos[0], pos[1], pos[2], radius) mothercn.addSolid(colsphere) return mothercn
def __init__(self, sender, pos, dir, damage, speed, range, accuracy=1): #bullets have a speed, a model, and a damage. Both should be parameters #range as well self.start = pos self.sender = sender self.accuracy = accuracy self.direction = dir.normalized() self.damage = damage self.tasks = [] self.speed = speed self.range = range self.model = base.loader.loadModel('models/bullet') self.model.reparentTo(base.render) self.model.setPos(pos) #self.target=target #create collision sphere #TODO account for larger bullet sizes cs = CollisionSphere(0, 0, 0, 1) self.mainCol = CollisionNode('cNode') #set up circular reference so collision volume knows parent self.mainCol.setPythonTag('owner', self) self.mainCol.setIntoCollideMask( CollideMask.bit(1) ) # send objects with intoCollideMask bit 1. Relates to most entities self.cNode = self.model.attachNewNode(self.mainCol) self.cNode.node().addSolid(cs) #create collider handler, if one doesn't already exist try: # attempt to add to global collision traverser base.cTrav.addCollider(self.cNode, base.bulletCollider) except AttributeError: base.bulletCollider = CollisionHandlerEvent() # create event called 'bulletCollision' on hit base.bulletCollider.addInPattern('bulletCollision') finally: # retry base.cTrav.addCollider(self.cNode, base.bulletCollider) #rotate model such that it follows the passed direction argument vector self.model.setHpr(helper.vectorToHPR(dir)) #assign direction based on rotation #THIS TOOK WAY TOO MUCH EFFORT TO FIGURE OUT #normVec here is the model nodepath taking the passed argument vector (dir) #belonging to another node (base.render) #and adjusting it to its local coordinate space - what would this vector look like from #self.model's perspective. Then it is normalized and assigned. normVec = self.model.getRelativeVector(base.render, dir) normVec.normalize() self.direction = normVec #normVec=base.render.getRelativeVector(self.model,Vec3(0,1,0)) #print(self.model.getHpr()) #print(normVec) #start task to move forward at speed self.tasks.append(taskMgr.add(self.accelerate, "bulletAccelerateTask"))
def setupCollision(self): self.sphere = self.model.attachNewNode(CollisionNode('range')) self.sphere.node().addSolid(CollisionSphere(0, 0, 0, self.range)) self.sphere.node().setFromCollideMask(BitMask32(2)) self.sphere.node().setIntoCollideMask(BitMask32.allOff()) self.cTrav = CollisionTraverser() self.cHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.sphere, self.cHandler)
def OnSpawn(self, parent): # Spawn in world (default) # Load a model for now its just one. self.seed = loader.loadModel("./assets/seed/seed") self.seedNP = self.seed.reparentTo(parent) self.seed.setZ(1) # Collision body cs = CollisionSphere(0, 0, 0, 0.4) cs.setTangible(False) self.cnodePath = self.seed.attachNewNode(CollisionNode("seedSphere-" + self.id)) self.cnodePath.node().addSolid(cs) self.cnodePath.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000 #self.cnodePath.show() self.seedState = 0
def initCollisions(self): self.collSphere = CollisionSphere(0, 0, 0, 1.25) self.collSphere.setTangible(1) name = 'CogThiefSphere-%d' % self.cogIndex self.collSphereName = self.uniqueName(name) self.collNode = CollisionNode(self.collSphereName) self.collNode.setIntoCollideMask(CTGG.BarrelBitmask | ToontownGlobals.WallBitmask) self.collNode.addSolid(self.collSphere) self.collNodePath = self.suit.attachNewNode(self.collNode) self.accept('enter' + self.collSphereName, self.handleEnterSphere) self.pieCollSphere = CollisionTube(0, 0, 0, 0, 0, 4, self.CollisionRadius) self.pieCollSphere.setTangible(1) name = 'CogThiefPieSphere-%d' % self.cogIndex self.pieCollSphereName = self.uniqueName(name) self.pieCollNode = CollisionNode(self.pieCollSphereName) self.pieCollNode.setIntoCollideMask(ToontownGlobals.PieBitmask) self.pieCollNode.addSolid(self.pieCollSphere) self.pieCollNodePath = self.suit.attachNewNode(self.pieCollNode)
def initCollisions(self): self.collSphere = CollisionSphere(0, 0, 0, 2.0) self.collSphere.setTangible(0) self.collNode = CollisionNode(self.uniqueName(self.COLL_SPHERE_NAME)) self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask) self.collNode.addSolid(self.collSphere) self.collNodePath = self.suit.attachNewNode(self.collNode) self.collNodePath.hide() self.accept(self.uniqueName('enter' + self.COLL_SPHERE_NAME), self.handleEnterSphere)
def initHearts(self): heartPositions = self.level.findAllMatches('**/*Heart*') self.hearts = [] i = 0 for pos in heartPositions: heart = loader.loadModel("Heart") heart.reparentTo(pos) heartRotation = heart.hprInterval(2.0, Vec3(360, 0, 0)) heartRotation.loop() heartsphere = CollisionSphere(0, 0, 0, 0.5) heartsphere.setTangible(False) heartColNP = heart.attachNewNode(CollisionNode('heart%d'%i)) heartColNP.node().addSolid(heartsphere) self.accept("playerCollision-in-heart%d"%i, self.__collectHeart, extraArgs=[i]) self.hearts.append(heart) i+=1
def setup_collision(self): self.target = CollisionSphere(0, 0, 0, 0.5) self.target_node = CollisionNode('collision_ship') self.target_node.setFromCollideMask(ENEMIES) self.target_node.setIntoCollideMask(ALLIES) self.target_nodepath = self.ship.model.attach_new_node( self.target_node) self.target_nodepath.node().addSolid(self.target)
def setup_collision(self): self.target = CollisionSphere(0, 0, 0, 1) self.target_node = CollisionNode('collision_entity') self.target_node.setFromCollideMask(ALLIES) # unused self.target_node.setIntoCollideMask(ENEMIES) self.target_nodepath = self.entity.model.attach_new_node( self.target_node) self.target_nodepath.node().addSolid(self.target) self.target_nodepath.show()
def __fireCannonTask(self, task): launchTime = task.fireTime avId = task.avId if self.toonHead == None or not self.boss.state == 'BattleTwo': return Task.done flightResults = self.__calcFlightResults(avId, launchTime) for key in flightResults: exec "%s = flightResults['%s']" % (key, key) self.notify.debug('start position: ' + str(startPos)) self.notify.debug('start velocity: ' + str(startVel)) self.notify.debug('time of launch: ' + str(launchTime)) self.notify.debug('time of impact: ' + str(timeOfImpact)) self.notify.debug('location of impact: ' + str(trajectory.getPos(timeOfImpact))) head = self.toonHead head.stopBlink() head.stopLookAroundNow() head.reparentTo(hidden) juror = self.toonModel juror.reparentTo(render) juror.setPos(startPos) barrelHpr = self.barrel.getHpr(render) juror.setHpr(startHpr) self.jurorToon.loop('swim') self.jurorToon.setPosHpr(0, 0, -(self.jurorToon.getHeight() / 2.0), 0, 0, 0) info = {} info['avId'] = avId info['trajectory'] = trajectory info['launchTime'] = launchTime info['timeOfImpact'] = timeOfImpact info['hitWhat'] = hitWhat info['toon'] = self.toonModel info['hRot'] = self.cannonPosition[0] info['haveWhistled'] = 0 info['maxCamPullback'] = CAMERA_PULLBACK_MIN if self.localToonShooting: camera.reparentTo(juror) camera.setP(45.0) camera.setZ(-10.0) self.flyColSphere = CollisionSphere(0, 0, self.av.getHeight() / 2.0, 1.0) self.flyColNode = CollisionNode(self.uniqueName('flySphere')) self.flyColNode.setCollideMask(ToontownGlobals.WallBitmask | ToontownGlobals.FloorBitmask | ToontownGlobals.PieBitmask) self.flyColNode.addSolid(self.flyColSphere) self.flyColNodePath = self.jurorToon.attachNewNode(self.flyColNode) self.flyColNodePath.setColor(1, 0, 0, 1) self.handler = CollisionHandlerEvent() self.handler.setInPattern(self.uniqueName('cannonHit')) base.cTrav.addCollider(self.flyColNodePath, self.handler) self.accept(self.uniqueName('cannonHit'), self.__handleCannonHit) shootTask = Task(self.__shootTask, self.taskName('shootTask')) flyTask = Task(self.__flyTask, self.taskName('flyTask')) shootTask.info = info flyTask.info = info seqTask = Task.sequence(shootTask, flyTask) taskMgr.add(seqTask, self.taskName('flyingToon') + '-' + str(avId)) self.acceptOnce(self.uniqueName('stopFlyTask'), self.__stopFlyTask) return Task.done
def announceGenerate(self): DistributedNode.announceGenerate(self) self.kart = loader.loadModel('phase_6/models/karting/Kart3_Final.bam') self.kart.find('**/decals').removeNode() self.kart.reparentTo(self) self.pod = loader.loadModel('phase_4/models/minigames/pods_truck.egg') self.pod.reparentTo(self) self.pod.setScale(0.2) self.pod.setY(8.5) self.pod.setH(180) self.pod.find('**/metal_ramp').setBin('ground', 18) self.pod.find('**/metal_ramp_coll').setCollideMask( CIGlobals.FloorBitmask) self.rope = Rope() self.rope.ropeNode.setUseVertexColor(1) self.rope.setup(3, ({ 'node': self.kart, 'point': (0, 1.5, 0.7), 'color': (0, 0, 0, 1), 'thickness': 1000 }, { 'node': self.kart, 'point': (0, 1.5, 0.7), 'color': (0, 0, 0, 1), 'thickness': 1000 }, { 'node': self.pod, 'point': (0, 31, 5), 'color': (0, 0, 0, 1), 'thickness': 1000 }), []) self.rope.setH(180) self.rope.reparentTo(self) sphere = CollisionSphere(0, 0, 0, 2) sphere.setTangible(0) node = CollisionNode(self.uniqueName('truck_trigger')) node.addSolid(sphere) node.setCollideMask(CIGlobals.WallBitmask) self.triggerNP = self.attachNewNode(node) self.triggerNP.setPos(0, 8.0, 2.0) self.setScale(2.0) self.accept('enter' + self.triggerNP.node().getName(), self.__handleTruckTrigger)
def start(self): self.gameApp.disableMouse() self.camera.setP(self.refNode, 0) self.camera.setR(self.refNode, 0) # hide mouse cursor, comment these 3 lines to see the cursor props = WindowProperties() props.setCursorHidden(True) self.gameApp.win.requestProperties(props) # reset mouse to start position: self.gameApp.win.movePointer(0, self.centX, self.centY) self.gameApp.taskMgr.add(self.cameraTask, 'HxMouseLook::cameraTask') # Task for changing direction/position self.accept("w", setattr, [self, "forward", True]) self.accept("shift-w", setattr, [self, "forward", True]) self.accept("w-up", setattr, [self, "forward", False]) self.accept("s", setattr, [self, "backward", True]) self.accept("shift-s", setattr, [self, "backward", True]) self.accept("s-up", setattr, [self, "backward", False]) self.accept("a", setattr, [self, "left", True]) self.accept("shift-a", setattr, [self, "left", True]) self.accept("a-up", setattr, [self, "left", False]) self.accept("d", setattr, [self, "right", True]) self.accept("shift-d", setattr, [self, "right", True]) self.accept("d-up", setattr, [self, "right", False]) self.accept("r", setattr, [self, "up", True]) self.accept("shift-r", setattr, [self, "up", True]) self.accept("r-up", setattr, [self, "up", False]) self.accept("f", setattr, [self, "down", True]) self.accept("shift-f", setattr, [self, "down", True]) self.accept("f-up", setattr, [self, "down", False]) self.accept("q", setattr, [self, "rollLeft", True]) self.accept("q-up", setattr, [self, "rollLeft", False]) self.accept("e", setattr, [self, "rollRight", True]) self.accept("e-up", setattr, [self, "rollRight", False]) self.accept("shift", setattr, [self, "fast", 10.0]) self.accept("shift-up", setattr, [self, "fast", 1.0]) # setup collisions # setup collisions if self.collisionHandler != None: # setup collisions nearDist = self.camera.node().getLens().getNear() # Create a collision node for this camera. # and attach it to the camera. self.collisionNP = self.camera.attachNewNode( CollisionNode("firstPersonCamera")) # Attach a collision sphere solid to the collision node. self.collisionNP.node().addSolid( CollisionSphere(0, 0, 0, nearDist * 1.1)) # self.collisionNP.show() # setup camera "from" bit-mask self.collisionNP.node().setFromCollideMask(self.collideMask) # add to collisionHandler (Pusher) self.collisionHandler.addCollider(self.collisionNP, self.camera) # add camera to collision system self.gameApp.cTrav.addCollider(self.collisionNP, self.collisionHandler)
def OnSpawn(self, parent): # Spawn in world (default) # Load a model for now its just one. self.seed = loader.loadModel("./assets/seed/seed") self.seedNP = self.seed.reparentTo(parent) self.seed.setZ(1) # Collision body cs = CollisionSphere(0, 0, 0, 0.4) cs.setTangible(False) self.cnodePath = self.seed.attachNewNode( CollisionNode("seedSphere-" + self.id)) self.cnodePath.node().addSolid(cs) self.cnodePath.node().setIntoCollideMask(BitMask32(0x80)) # 1000 0000 #self.cnodePath.show() self.seedState = 0
def frowneyMachine(n, pos): frowneyModel = loader.loadModel('frowney') frowneyModel.setName('Frowney#%d' % n) frowneyModel.reparentTo(render) frowneyModel.setPos(pos) frowneyCollider = frowneyModel.attachNewNode( CollisionNode('frowneycnode%d' % n)) frowneyCollider.node().addSolid(CollisionSphere(0, 0, 0, 1)) # as for the smileys, we set here the tag to recognize later all the frowneys - take note of the tag and its value frowneyCollider.setTag('balls', 'frowney')
def attachCollisionSphere(self, name, cx, cy, cz, r, fromCollide, intoCollide): from panda3d.core import CollisionSphere from panda3d.core import CollisionNode coll = CollisionSphere(cx, cy, cz, r) collNode = CollisionNode(name) collNode.addSolid(coll) collNode.setFromCollideMask(fromCollide) collNode.setIntoCollideMask(intoCollide) collNodePath = self.attachNewNode(collNode) return collNodePath
def attachcollnodes(self): for i in range(5): self.fromObject = self.players[i].attachNewNode(CollisionNode('colfromNode'+str(i))) self.fromObject.node().addSolid(CollisionSphere(0,0,0,1)) self.cTrav.addCollider(self.fromObject, self.chandler) for i in range(5): self.accept('colfromNode%d-into-colintoNode' % i, self.collide1,[i]) self.accept('colfromNode%d-again-colintoNode' % i, self.collide2,[i]) self.accept('colfromNode%d-outof-colintoNode' % i, self.collide3,[i])
def __init__(self): FSM.__init__(self, "FSM-Golem") random.seed() self.golem = loader.loadModel("Golem") self.golem = Actor("Golem", { "Idle":"Golem-Idle", "Walk":"Golem-Walk", "Attack":"Golem-Attack", "Destroyed":"Golem-Destroyed"}) self.golem.setBlend(frameBlend = True) golemViewSphere = CollisionSphere(0, 0, 0.5, 6) golemViewSphere.setTangible(False) golemViewColNP = self.golem.attachNewNode(CollisionNode('golemViewField')) golemViewColNP.node().addSolid(golemViewSphere) golemHitSphere = CollisionSphere(0, 0, 0.5, 1) golemHitColNP = self.golem.attachNewNode(CollisionNode('golemHitField')) golemHitColNP.node().addSolid(golemHitSphere) # a collision segment to check attacks self.attackCheckSegment = CollisionSegment(0, 0, 1, 0, -1.3, 1) self.golemAttackRay = self.golem.attachNewNode(CollisionNode("golemAttackCollision")) self.golemAttackRay.node().addSolid(self.attackCheckSegment) self.golemAttackRay.node().setIntoCollideMask(0) self.attackqueue = CollisionHandlerQueue() base.cTrav.addCollider(self.golemAttackRay, self.attackqueue) attackAnim = self.golem.actorInterval("Attack", playRate = 2) self.AttackSeq = Parallel( attackAnim, Sequence( Wait(0.5), Func(self.ceckAttack) )) self.lookatFloater = NodePath(PandaNode("golemTracker")) self.lookatFloater.setPos(self.golem, 0, 0, 3.4) self.lookatFloater.hide() self.lookatFloater.reparentTo(render) self.trackerObject = loader.loadModel("misc/Pointlight") self.trackerObject.setColor(0, 1, 0) self.trackerObject.setScale(0.25) self.trackerObject.reparentTo(self.lookatFloater)
def initPostsigns(self): objects = self.level.findAllMatches('**/Signpost.*') self.postsigns = {} i = 0 for object in objects: postsphere = CollisionSphere(0, 0, 0.5, 1) postsphere.setTangible(False) postColNP = object.attachNewNode(CollisionNode('postsignInfo%d'%i)) postColNP.node().addSolid(postsphere) self.postsigns.setdefault(object, postColNP) postName = object.getName() self.accept("playerCollision-in-postsignInfo%d"%i, self.__setActivateElement, extraArgs=[True, postName, "postsign"]) self.accept("playerCollision-out-postsignInfo%d"%i, self.__setActivateElement, extraArgs=[False, postName, "postsign"]) i+=1
def loadAssets(self): self.root = render.attachNewNode('golfSpot-%d' % self.index) self.root.setPos(*self.positions[self.index]) self.ballModel = loader.loadModel('phase_6/models/golf/golf_ball') self.ballColor = VBase4(1, 1, 1, 1) if self.index < len(GolfGlobals.PlayerColors): self.ballColor = VBase4(*GolfGlobals.PlayerColors[self.index]) self.ballModel.setColorScale(self.ballColor) self.ballModel.reparentTo(self.root) self.club = loader.loadModel('phase_6/models/golf/putter') self.clubLookatSpot = self.root.attachNewNode('clubLookat') self.clubLookatSpot.setY(-(GolfGlobals.GOLF_BALL_RADIUS + 0.1)) cs = CollisionSphere(0, 0, 0, 1) cs.setTangible(0) cn = CollisionNode(self.triggerName) cn.addSolid(cs) cn.setIntoCollideMask(ToontownGlobals.WallBitmask) self.trigger = self.root.attachNewNode(cn) self.trigger.stash() self.hitBallSfx = loader.loadSfx('phase_6/audio/sfx/Golf_Hit_Ball.ogg')
def loadAttack(self): self.pen = loader.loadModel('phase_5/models/props/pen.bam') self.pen.reparentTo(self.suit.find('**/joint_Rhold')) self.sprayParticle = ParticleLoader.loadParticleEffect('phase_5/etc/penSpill.ptf') self.spray = loader.loadModel('phase_3.5/models/props/spray.bam') self.spray.setColor(VBase4(0, 0, 0, 1)) self.splat = Actor('phase_3.5/models/props/splat-mod.bam', {'chan': 'phase_3.5/models/props/splat-chan.bam'}) self.splat.setColor(VBase4(0, 0, 0, 1)) self.sprayScaleIval = LerpScaleInterval(self.spray, duration=0.3, scale=(1, 20, 1), startScale=(1, 1, 1)) sphere = CollisionSphere(0, 0, 0, 0.5) sphere.setTangible(0) if hasattr(self.suit, 'uniqueName'): collName = self.suit.uniqueName('fountainPenCollNode') else: collName = 'fountainPenCollNode' collNode = CollisionNode(collName) collNode.addSolid(sphere) collNode.setCollideMask(CIGlobals.WallBitmask) self.wsnp = self.spray.attachNewNode(collNode) self.wsnp.setY(1)
def makeNodePath(self): self.nodePath = NodePath('treasure') if self.billboard: self.nodePath.setBillboardPointEye() self.nodePath.setScale(0.9 * self.scale) self.treasure = self.nodePath.attachNewNode('treasure') if self.shadow: if not self.dropShadow: self.dropShadow = loader.loadModel('phase_3/models/props/drop_shadow.bam') self.dropShadow.setColor(0, 0, 0, 0.5) self.dropShadow.setPos(0, 0, 0.025) self.dropShadow.setScale(0.4 * self.scale) self.dropShadow.flattenLight() self.dropShadow.reparentTo(self.nodePath) collSphere = CollisionSphere(0, 0, 0, self.sphereRadius) collSphere.setTangible(0) collNode = CollisionNode(self.uniqueName('treasureSphere')) collNode.setIntoCollideMask(CIGlobals.WallBitmask) collNode.addSolid(collSphere) self.collNodePath = self.nodePath.attachNewNode(collNode) self.collNodePath.stash()
def generateInit(self): DistributedFireworkShow.DistributedFireworkShow.generateInit(self) self.fireworksSphereEvent = self.uniqueName('fireworksSphere') self.fireworksSphereEnterEvent = 'enter' + self.fireworksSphereEvent self.fireworksGuiDoneEvent = 'fireworksGuiDone' self.shootEvent = 'fireworkShootEvent' self.collSphere = CollisionSphere(0, 0, 0, 2.5) self.collSphere.setTangible(1) self.collNode = CollisionNode(self.fireworksSphereEvent) self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask) self.collNode.addSolid(self.collSphere) self.collNodePath = self.geom.attachNewNode(self.collNode)
def setupElevatorKart(self): collisionRadius = ElevatorConstants.ElevatorData[self.type]['collRadius'] self.elevatorSphere = CollisionSphere(0, 0, 0, collisionRadius) self.elevatorSphere.setTangible(1) self.elevatorSphereNode = CollisionNode(self.uniqueName('elevatorSphere')) self.elevatorSphereNode.setIntoCollideMask(ToontownGlobals.WallBitmask) self.elevatorSphereNode.addSolid(self.elevatorSphere) self.elevatorSphereNodePath = self.getElevatorModel().attachNewNode(self.elevatorSphereNode) self.elevatorSphereNodePath.hide() self.elevatorSphereNodePath.reparentTo(self.getElevatorModel()) self.elevatorSphereNodePath.stash() self.boardedAvIds = {} self.finishSetup()