示例#1
0
def initCollisionSphere(obj, desc, radiusMultiplier):
	# 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))

	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)
示例#2
0
 def _initCollisions(self):
     self._camCollRay = CollisionRay()
     camCollNode = CollisionNode('CameraToonRay')
     camCollNode.addSolid(self._camCollRay)
     camCollNode.setFromCollideMask(OTPGlobals.WallBitmask | OTPGlobals.CameraBitmask | ToontownGlobals.FloorEventBitmask | ToontownGlobals.CeilingBitmask)
     camCollNode.setIntoCollideMask(0)
     self._camCollNP = self._camera.attachNewNode(camCollNode)
     self._camCollNP.show()
     self._collOffset = Vec3(0, 0, 0.5)
     self._collHandler = CollisionHandlerQueue()
     self._collTrav = CollisionTraverser()
     self._collTrav.addCollider(self._camCollNP, self._collHandler)
     self._betweenCamAndToon = {}
     self._transNP = NodePath('trans')
     self._transNP.reparentTo(render)
     self._transNP.setTransparency(True)
     self._transNP.setAlphaScale(Globals.Camera.AlphaBetweenToon)
     self._transNP.setBin('fixed', 10000)
示例#3
0
 def __endFireWater(self):
     if self.aimStart == None:
         return
     if not self.state == 'Controlled':
         return
     if not self.avId == localAvatar.doId:
         return
     taskMgr.remove(self.waterPowerTaskName)
     messenger.send('wakeup')
     self.aimStart = None
     origin = self.nozzle.getPos(render)
     target = self.boss.getPos(render)
     angle = deg2Rad(self.waterPitcherNode.getH() + 90)
     x = math.cos(angle)
     y = math.sin(angle)
     fireVector = Point3(x, y, 0)
     if self.power < 0.001:
         self.power = 0.001
     self.lastPowerFired = self.power
     fireVector *= self.fireLength * self.power
     target = origin + fireVector
     segment = CollisionSegment(origin[0], origin[1], origin[2], target[0],
                                target[1], target[2])
     fromObject = render.attachNewNode(CollisionNode('pitcherColNode'))
     fromObject.node().addSolid(segment)
     fromObject.node().setFromCollideMask(ToontownGlobals.PieBitmask
                                          | ToontownGlobals.CameraBitmask
                                          | ToontownGlobals.FloorBitmask)
     fromObject.node().setIntoCollideMask(BitMask32.allOff())
     queue = CollisionHandlerQueue()
     base.cTrav.addCollider(fromObject, queue)
     base.cTrav.traverse(render)
     queue.sortEntries()
     self.hitObject = None
     if queue.getNumEntries():
         entry = queue.getEntry(0)
         target = entry.getSurfacePoint(render)
         self.hitObject = entry.getIntoNodePath()
     base.cTrav.removeCollider(fromObject)
     fromObject.removeNode()
     self.d_firingWater(origin, target)
     self.fireWater(origin, target)
     self.resetPowerBar()
     return
 def __init__(self, object, name, proximityText):
     DirectObject.__init__(self)
     self.object = object
     self.proximityText = proximityText
     self.proximityEvent = name
     self.enterProximityEvent = 'enter' + name
     self.exitProximityEvent = 'exit' + name
     self.useLabel = None
     self.fader = None
     self.size = 6
     self.disk = None
     proximitySphere = CollisionSphere(0, 0, 0, self.size)
     proximitySphere.setTangible(0)
     proximityNode = CollisionNode(self.proximityEvent)
     proximityNode.setIntoCollideMask(PiratesGlobals.WallBitmask)
     proximityNode.addSolid(proximitySphere)
     self.proximityNodePath = self.object.attachNewNode(proximityNode)
     self.accept(self.enterProximityEvent, self.approach)
     self.accept(self.exitProximityEvent, self.leave)
示例#5
0
    def initCollisionSphere(self, obj,show=False):
        # Get the size of the object for the collision sphere.
        bounds = obj.getChild(0).getBounds()
        center = bounds.getCenter()
        radius = bounds.getRadius() *0.5
 
        # Create a collison sphere
        collSphereStr = 'CollisionHull' + str(self.collCount) + "_" + obj.getName()
        self.collCount += 1
        cNode = CollisionNode(collSphereStr)
        cNode.addSolid(CollisionSphere(center, radius))
 
        cNodepath = obj.attachNewNode(cNode)
	#cNodepath.show()
        
 
        # Return a tuple with the collision node and its corrsponding string so
        # that the bitmask can be set.
        return (cNodepath, collSphereStr)
示例#6
0
    def setupElevatorKart(self):
        """Setup elevator related fields."""
        # Establish a collision sphere. There must be an easier way!
        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()
示例#7
0
    def pieThrow(self, avId, timestamp, heading, pos, power):
        toon = self.activity.getAvatar(avId)
        if toon is None:
            return
        tossTrack, pieTrack, flyPie = self.getTossPieInterval(
            toon, pos[0], pos[1], pos[2], heading, 0, 0, power)
        if avId == base.localAvatar.doId:
            flyPie.setTag('throwerId', str(avId))
            collSphere = CollisionSphere(0, 0, 0, 0.5)
            collSphere.setTangible(0)
            name = 'PieSphere-%d' % avId
            collSphereName = self.activity.uniqueName(name)
            collNode = CollisionNode(collSphereName)
            collNode.setFromCollideMask(ToontownGlobals.PieBitmask)
            collNode.addSolid(collSphere)
            collNP = flyPie.attachNewNode(collNode)
            base.cTrav.addCollider(collNP, self.pieHandler)
            self.toonPieEventNames[collNP] = 'pieHit-' + collSphereName
            self.accept(self.toonPieEventNames[collNP],
                        self.handlePieCollision)
        else:
            player = self.players.get(avId)
            if player is not None:
                player.faceForward()

        def matchRunningAnim(toon=toon):
            toon.playingAnim = None
            toon.setSpeed(toon.forwardSpeed, toon.rotateSpeed)
            return

        newTossTrack = Sequence(tossTrack, Func(matchRunningAnim))
        pieTrack = Parallel(newTossTrack,
                            pieTrack,
                            name='PartyCogActivity.pieTrack-%d-%s' %
                            (avId, timestamp))
        elapsedTime = globalClockDelta.localElapsedTime(timestamp)
        if elapsedTime < 16.0 / 24.0:
            elapsedTime = 16.0 / 24.0
        pieTrack.start(elapsedTime)
        self.pieIvals.append(pieTrack)
        self.toonPieTracks[avId] = pieTrack
        return
示例#8
0
 def createRainDrop(self, x=0, y=0, doubleDrop=False, tripleDrop=False):
     # Set up line geometry for rain.
     id = str(uuid.uuid4())
     dummy = NodePath('dummy' + id)
     lineSegs = LineSegs('line' + id)
     if self.tripleDrop:
         lineSegs.setThickness(3.0)
     elif self.doubleDrop:
         lineSegs.setThickness(2.0)
     else:
         lineSegs.setThickness(1.0)
     lineSegs.moveTo(0, 0, 0)
     lineSegs.drawTo(0, 0, self.deltaZ * .1)
     lineGeomNode = lineSegs.create()
     # True: gray; False: white and red.
     if True:
         lineSegs.setVertexColor(0, Vec4(1, 1, 1, .4))
         lineSegs.setVertexColor(1, Vec4(.3, .3, .3, 0))
         pass
     else:
         lineSegs.setVertexColor(0, Vec4(1, 1, 1, .4))
         lineSegs.setVertexColor(1, Vec4(1, 0, 0, 1))
     linePath = dummy.attachNewNode(lineGeomNode)
     linePath.setTransparency(True)
     linePath.reparentTo(render)
     # Add collision node with 'FROM' tag = 'rain'
     pickerNode = CollisionNode('linecnode' + id)
     pickerNode.setTag('FROM', 'rain')
     rayCollider = linePath.attachNewNode(pickerNode)
     # A small collision sphere is attached to the bottom of each rain drop.
     rayCollider.node().addSolid(CollisionSphere(0, 0, 0, .25))
     #base.cTrav.addCollider(rayCollider, collisionHandler)
     # Sequence rain
     Sequence(
         LerpPosInterval(linePath,
                         self.dropDuration,
                         Point3(x, y, self.pt1.z),
                         Point3(x, y, self.pt2.z),
                         blendType='easeIn',
                         fluid=1),
         Parallel(Func(dummy.removeNode),
                  Func(linePath.removeNode))).start()
示例#9
0
    def createHotspotCollisionGeom(self, hp):
        '''
        Creates a collision box that covers the hotspot's interactive area in order to be able to detect a hotspot
        by raycasting from the mouse position.
        '''
        dim = self.getFaceTextureDimensions(hp.face)

        # get world space coords of top left corner
        t1 = hp.xo / dim[0]
        t2 = hp.yo / dim[1]
        topLeft = self.getWorldPointFromFacePoint(hp.face, (t1, t2))

        # get world space coords of top right corner
        t1 = hp.xe / dim[0]
        t2 = hp.yo / dim[1]
        topRight = self.getWorldPointFromFacePoint(hp.face, (t1, t2))

        # get world space coords of bottom right corner
        t1 = hp.xe / dim[0]
        t2 = hp.ye / dim[1]
        bottomRight = self.getWorldPointFromFacePoint(hp.face, (t1, t2))

        # get world space coords of bottom left corner
        t1 = hp.xo / dim[0]
        t2 = hp.ye / dim[1]
        bottomLeft = self.getWorldPointFromFacePoint(hp.face, (t1, t2))

        #        polygon = CollisionPolygon(topLeft, bottomLeft, bottomRight, topRight)
        polygon = CollisionPolygon(topLeft, topRight, bottomRight, bottomLeft)

        # name it as the hotspot, it will be convenient for raycasting
        cn = CollisionNode(hp.name)
        cn.addSolid(polygon)

        collisionNP = NodePath(cn)
        collisionNP.setName(hp.name)
        collisionNP.reparentTo(self.collisionsGeomsParent)

        if not hp.active:
            collisionNP.hide()
        else:
            collisionNP.show()
示例#10
0
    def placeNPC(self, name, x, y):
        npcScale = 1
        npcTexture = loader.loadTexture("textures/texRock2.png")

        self.npc = self.loader.loadModel("models/man.x")
        self.npcNode = render.attachNewNode("NpcNode")
        self.npc.reparentTo(self.npcNode)
        self.npcName += [name]
        self.npc.setName(name)
        self.npc.setScale(1, 1, 1)
        self.npc.setPos(x, y, 0)
        self.npcX += [x]
        self.npcY += [y]

        self.npc.setTexture(npcTexture)

        self.npcCollider = self.npc.attachNewNode(CollisionNode("npcCollider"))
        self.npcCollider.node().addSolid(CollisionSphere(0, 0, 0, 5))

        self.countNpc += 1
示例#11
0
    def addTrigger(self, name, pos, radius):
        '''
		http://www.panda3d.org/apiref.php?page=DirectObject
		http://www.panda3d.org/wiki/index.php/Collision_Solids
		http://www.panda3d.org/apiref.php?page=CollisionTraverser
		http://www.panda3d.org/apiref.php?page=CollisionHandlerEvent
		http://www.panda3d.org/apiref.php?page=NodePath#find
		'''
        cSphere = CollisionSphere(pos[0], pos[1], pos[2], radius)
        cNode = CollisionNode(name)
        cNode.addSolid(cSphere)

        model = render.find(name)
        if not model.isEmpty():
            model.removeNode()

        cnodePath = render.attachNewNode(cNode)
        cnodePath.show()
        base.cTrav.addCollider(cnodePath, self.collHandEvent)
        base.accept('into-' + name, self.onTrigger)
示例#12
0
 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')
示例#13
0
 def initialize(self):
     """
     To setup collision detection we need:
         a. A CollisionNode having a ray as its solid and placed at the position
            of the camera while also having the same orientation as the camera.
         b. A new nodepath placed in the scenegraph as an immediate child of the
            camera. It will be used to insert the collision node in the scenegraph.
         c. A CollisionRay for firing rays based on mouse clicks.
         d. A collisions traverser.
         e. A collisions queue where all found collisions will be stored for later
            processing.
     """
     self.traverser = CollisionTraverser('Hotspots collision traverser')
     self.collisionsQueue = CollisionHandlerQueue()
     self.pickerNode = CollisionNode('mouseRay')
     self.pickerRay = CollisionRay()
     self.pickerNode.addSolid(self.pickerRay)
     self.pickerNP = self.renderer.getCamera().attachNewNode(
         self.pickerNode)
     self.traverser.addCollider(self.pickerNP, self.collisionsQueue)
示例#14
0
 def __init__(self, model, pos, serialNum, gameId, penalty=False):
     self.serialNum = serialNum
     self.penalty = penalty
     center = model.getBounds().getCenter()
     center = Point3(0, 0, 0)
     self.nodePath = model.copyTo(render)
     self.nodePath.setPos(pos[0] - center[0], pos[1] - center[1],
                          pos[2] - center[2])
     self.nodePath.setZ(0)
     self.notify.debug('newPos = %s' % self.nodePath.getPos())
     if self.penalty:
         self.sphereName = 'penaltySphere-%s-%s' % (gameId, self.serialNum)
     else:
         self.sphereName = 'treasureSphere-%s-%s' % (gameId, self.serialNum)
     self.collSphere = CollisionSphere(center[0], center[1], center[2],
                                       self.RADIUS)
     self.collSphere.setTangible(0)
     self.collNode = CollisionNode(self.sphereName)
     self.collNode.setIntoCollideMask(ToontownGlobals.PieBitmask)
     self.collNode.addSolid(self.collSphere)
     self.collNodePath = render.attachNewNode(self.collNode)
     self.collNodePath.setPos(pos[0] - center[0], pos[1] - center[1],
                              pos[2] - center[2])
     self.collNodePath.hide()
     self.track = None
     if self.penalty:
         self.tip = self.nodePath.find('**/fusetip')
         sparks = BattleParticles.createParticleEffect(file='icetnt')
         self.sparksEffect = sparks
         sparks.start(self.tip)
         self.penaltyGrabSound = loader.loadSfx(
             'phase_4/audio/sfx/MG_cannon_fire_alt.mp3')
         self.penaltyGrabSound.setVolume(0.75)
         kaboomAttachPoint = self.nodePath.attachNewNode('kaboomAttach')
         kaboomAttachPoint.setZ(3)
         self.kaboom = loader.loadModel(
             'phase_4/models/minigames/ice_game_kaboom')
         self.kaboom.reparentTo(kaboomAttachPoint)
         self.kaboom.setScale(2.0)
         self.kaboom.setBillboardPointEye()
     return
示例#15
0
    def createCollisionHandlers(self):
        # Create a new collision traverser instance. We will use this to determine
        # if any collisions occurred after performing movement.
        self.cTrav = CollisionTraverser()

        camGroundRay = CollisionRay()
        camGroundRay.setOrigin(0, 0, 1000)
        camGroundRay.setDirection(0, 0, -1)
        camGroundCol = CollisionNode('camRay')
        camGroundCol.addSolid(camGroundRay)
        camGroundCol.setFromCollideMask(BitMask32.bit(0))
        camGroundCol.setIntoCollideMask(BitMask32.allOff())
        camGroundColNp = base.camera.attachNewNode(camGroundCol)
        self.camGroundHandler = CollisionHandlerQueue()
        self.cTrav.addCollider(camGroundColNp, self.camGroundHandler)

        # register the collision pusher
        self.pusher = CollisionHandlerPusher()

        # register collision event pattern names
        self.pusher.addInPattern('col-%fn-into')
示例#16
0
文件: Controller.py 项目: crempp/psg
    def __init__(self):
        ''' Should the traverser be shared? '''

        LOG.debug("[Selector] Initializing")

        # The collision traverser does the checking of solids for collisions
        self.cTrav = CollisionTraverser()

        # The collision handler queue is a simple handler that records all
        # detected collisions during traversal
        self.cHandler = CollisionHandlerQueue()

        self.pickerNode = CollisionNode('mouseRay')
        self.pickerNP = camera.attachNewNode(self.pickerNode)
        self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
        self.pickerRay = CollisionRay()
        self.pickerNode.addSolid(self.pickerRay)
        self.cTrav.addCollider(self.pickerNP, self.cHandler)

        # Start listening to clicks
        self.resume()
示例#17
0
 def loadModel(self):
     self.hill = loader.loadModel('phase_12/models/bossbotHQ/mole_hole')
     self.hill.setZ(0.0)
     self.hill.reparentTo(self)
     self.hillColName = 'moleHillCol-%d-%d' % (self.moleField.doId, self.index)
     self.moleField.accept('enter' + self.hillColName, self.moleField.handleEnterHill)
     self.mole = self.attachNewNode('mole')
     self.mole.reparentTo(self)
     self.mole.setScale(0.75)
     self.mole.setZ(-2.5)
     self.moleHead = loader.loadModel('phase_12/models/bossbotHQ/mole_norm')
     self.moleHead.reparentTo(self.mole)
     moleColName = 'moleCol-%d-%s' % (self.moleField.doId, self.index)
     moleSphere = CollisionTube(0, 0, 0, 0, 0, 1, 1)
     collNode = CollisionNode(moleColName)
     collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
     collNode.addSolid(moleSphere)
     self.moleColNodePath = self.mole.attachNewNode(collNode)
     self.moleColNodePath.stash()
     self.moleColNodePath.setScale(1.0)
     self.moleField.accept('enter' + moleColName, self.moleField.handleEnterMole)
示例#18
0
文件: picker.py 项目: croxis/apollo
 def createRay(self,
               obj,
               ent,
               name,
               show=False,
               x=0,
               y=0,
               z=0,
               dx=0,
               dy=0,
               dz=-1):
     #create queue
     obj.queue = CollisionHandlerQueue()
     #create ray
     obj.rayNP = ent.attachNewNode(CollisionNode(name))
     obj.ray = CollisionRay(x, y, z, dx, dy, dz)
     obj.rayNP.node().addSolid(obj.ray)
     obj.rayNP.node().setFromCollideMask(GeomNode.getDefaultCollideMask())
     sandbox.pickTrav.addCollider(obj.rayNP, obj.queue)
     if show:
         obj.rayNP.show()
示例#19
0
    def setupCollisions(self):
        self.coll_trav = CollisionTraverser()

        self.player_ground_sphere = CollisionSphere(0, 1.5, -1.5, 1.5)
        self.player_ground_col = CollisionNode('playerSphere')
        self.player_ground_col.addSolid(self.player_ground_sphere)

        # bitmasks
        self.player_ground_col.setFromCollideMask(BitMask32.bit(0))
        self.player_ground_col.setIntoCollideMask(BitMask32.allOff())
        self.world.setCollideMask(BitMask32.bit(0))
        self.water.setCollideMask(BitMask32.bit(0))

        # and done
        self.player_ground_col_np = self.player.attachNewNode(self.player_ground_col)
        self.player_ground_handler = CollisionHandlerQueue()
        self.coll_trav.addCollider(self.player_ground_col_np, self.player_ground_handler)

        # DEBUG
        if self.debug:
            self.player_ground_col_np.show()
            self.coll_trav.showCollisions(self.render)
示例#20
0
 def generate(self):
     DistributedObject.DistributedObject.generate(self)
     loader = self.cr.playGame.hood.loader
     partyGate = loader.geom.find('**/partyGate_grp')
     if partyGate.isEmpty():
         self.notify.warning('Could not find partyGate_grp in loader.geom')
         return
     self.clockFlat = partyGate.find('**/clock_flat')
     collSphere = CollisionSphere(0, 0, 0, 6.9)
     collSphere.setTangible(1)
     self.partyGateSphere = CollisionNode('PartyGateSphere')
     self.partyGateSphere.addSolid(collSphere)
     self.partyGateCollNodePath = partyGate.find('**/partyGate_stepsLocator').attachNewNode(self.partyGateSphere)
     self.__enableCollisions()
     self.toontownTimeGui = ServerTimeGui(partyGate, hourCallback=self.hourChange)
     self.toontownTimeGui.setPos(partyGate.find('**/clockText_locator').getPos() + Point3(0.0, 0.0, -0.2))
     self.toontownTimeGui.setHpr(partyGate.find('**/clockText_locator').getHpr())
     self.toontownTimeGui.setScale(12.0, 1.0, 26.0)
     self.toontownTimeGui.amLabel.setPos(-0.035, 0, -0.032)
     self.toontownTimeGui.amLabel.setScale(0.5)
     self.toontownTimeGui.updateTime()
     self.setupSignText()
    def showToonThrowingPie(self, avId, timestamp, heading, pos):
        toon = self.getAvatar(avId)
        if toon:
            (tossTrack, pieTrack,
             flyPie) = self.getTossPieInterval(toon, pos[0], pos[1], pos[2],
                                               heading, 0, 0, 0)

            def removePieFromTraverser(flyPie=flyPie):
                if base.cTrav:
                    if flyPie:
                        base.cTrav.removeCollider(flyPie)

            if avId == self.localAvId:
                flyPie.setTag('throwerId', str(avId))
                collSphere = CollisionSphere(0, 0, 0, 0.5)
                collSphere.setTangible(0)
                name = 'PieSphere-%d' % avId
                collSphereName = self.uniqueName(name)
                collNode = CollisionNode(collSphereName)
                collNode.setFromCollideMask(ToontownGlobals.PieBitmask)
                collNode.addSolid(collSphere)
                colNp = flyPie.attachNewNode(collNode)
                colNp.show()
                base.cTrav.addCollider(colNp, self.pieHandler)
                self.accept('pieHit-' + collSphereName, self.handlePieHitting)

            def matchRunningAnim(toon=toon):
                toon.playingAnim = None
                toon.setSpeed(toon.forwardSpeed, toon.rotateSpeed)

            newTossTrack = Sequence(tossTrack, Func(matchRunningAnim))
            pieTrack = Parallel(newTossTrack, pieTrack)
            elapsedTime = globalClockDelta.localElapsedTime(timestamp)
            if elapsedTime < 16.0 / 24.0:
                elapsedTime = 16.0 / 24.0

            pieTrack.start(elapsedTime)
            self.toonPieTracks[avId] = pieTrack
示例#22
0
    def initCollisionSphere(self, obj, setX, setY, setZ, show=False):
        # Get the size of the object for the collision sphere.
        bounds = obj.getChild(0).getBounds()
        center = bounds.getCenter()
        radius = bounds.getRadius() * 0.6

        # Create a collision sphere and name it something understandable.
        collSphereStr = 'CollisionHull' + str(
            self.collCount) + "_" + obj.getName()
        self.collCount += 1
        self.accept('arrow_down', self.moved, [0])
        self.accept('arrow_up', self.move, [0])
        cNode = CollisionNode(collSphereStr)
        #	cNode.setScale(3,3,3)
        cNode.addSolid(CollisionSphere(center, radius))

        cNodepath = obj.attachNewNode(cNode)
        cNodepath.setScale(setX, setY, setZ)
        #cNodepath.show()

        # Return a tuple with the collision node and its corrsponding string so
        # that the bitmask can be set.
        return (cNodepath, collSphereStr)
示例#23
0
    def gameLoop(self, task):
        #print "game task"

        # ***************** SET CAMERA ******************

        base.taskMgr.add(self.rotateCamera, "rotateCamera")

        self.game.setPlayer(self.player)

        # ***************** PICKABLE SHITS ***************
        # setup the pickable suqre planes on the board
        planes = []
        id_plane = 0
        for k in range(3):
            for i in range(3):
                #print "adding plane: ", id_plane
                p = addPlane(3)
                p.setPos(3 * i - 2.5, 3 * k - 2.5, 3.1)
                p.setTag('pickable', str(id_plane))
                p.hide()
                planes.append(p)
                id_plane += 1

        # set picks
        pickerNode = CollisionNode('mouseRay')
        pickerNP = self.cam.attachNewNode(pickerNode)
        pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
        self.pickerRay = CollisionRay()
        pickerNode.addSolid(self.pickerRay)
        #pickerNP.show()
        self.rayQueue = CollisionHandlerQueue()
        self.cTrav = CollisionTraverser()
        self.cTrav.addCollider(pickerNP, self.rayQueue)

        # set action in case of pick
        self.accept('mouse1', self.picked)
示例#24
0
    def generate(self):
        """generate(self)
        This method is called when the DistributedObject is reintroduced
        to the world, either for the first time or from the cache.
        """
        DistributedObject.DistributedObject.generate(self)

        loader = self.cr.playGame.hood.loader
        partyGate = loader.geom.find('**/partyGate_grp')
        if partyGate.isEmpty():
            self.notify.warning('Could not find partyGate_grp in loader.geom')
            return
        self.clockFlat = partyGate.find("**/clock_flat")
        collSphere = CollisionSphere(0, 0, 0, 6.9)
        collSphere.setTangible(1)
        self.partyGateSphere = CollisionNode("PartyGateSphere")
        self.partyGateSphere.addSolid(collSphere)
        self.partyGateCollNodePath = partyGate.find(
            "**/partyGate_stepsLocator").attachNewNode(self.partyGateSphere)
        self.__enableCollisions()
        #        self.tunnelOrigin = NodePath("PartyGateTunnelOrigin")
        #        self.tunnelOrigin.reparentTo(partyGate)
        #        self.tunnelOrigin.setPos(partyGate.find("**/clockText_locator").getPos() + Point3(0.0, 0.0, -12.0))

        self.toontownTimeGui = ServerTimeGui(partyGate,
                                             hourCallback=self.hourChange)
        self.toontownTimeGui.setPos(
            partyGate.find("**/clockText_locator").getPos() +
            Point3(0.0, 0.0, -0.2))
        self.toontownTimeGui.setHpr(
            partyGate.find("**/clockText_locator").getHpr())
        self.toontownTimeGui.setScale(12.0, 1.0, 26.0)
        self.toontownTimeGui.amLabel.setPos(-0.035, 0, -0.032)
        self.toontownTimeGui.amLabel.setScale(0.5)
        self.toontownTimeGui.updateTime()
        self.setupSignText()
 def setupTire(self, avId, index):
     tireNp, tireBody, tireOdeGeom = self.createTire(index)
     self.tireDict[avId] = {'tireNodePath': tireNp,
      'tireBody': tireBody,
      'tireOdeGeom': tireOdeGeom}
     if avId <= 0:
         tireBlocker = tireNp.find('**/tireblockermesh')
         if not tireBlocker.isEmpty():
             tireBlocker.hide()
     if avId == self.localAvId:
         tireNp = self.tireDict[avId]['tireNodePath']
         self.treasureSphereName = 'treasureCollider'
         self.treasureCollSphere = CollisionSphere(0, 0, 0, IceGameGlobals.TireRadius)
         self.treasureCollSphere.setTangible(0)
         self.treasureCollNode = CollisionNode(self.treasureSphereName)
         self.treasureCollNode.setFromCollideMask(ToontownGlobals.PieBitmask)
         self.treasureCollNode.addSolid(self.treasureCollSphere)
         self.treasureCollNodePath = tireNp.attachNewNode(self.treasureCollNode)
         self.treasureHandler = CollisionHandlerEvent()
         self.treasureHandler.addInPattern('%fn-intoTreasure')
         base.cTrav.addCollider(self.treasureCollNodePath, self.treasureHandler)
         eventName = '%s-intoTreasure' % self.treasureCollNodePath.getName()
         self.notify.debug('eventName = %s' % eventName)
         self.accept(eventName, self.toonHitSomething)
示例#26
0
    def load(self):
        self.notify.debug('load')
        DistributedMinigame.load(self)
        self.music = base.loadMusic('phase_4/audio/bgm/MG_CogThief.ogg')
        self.initCogInfo()
        for barrelIndex in xrange(CTGG.NumBarrels):
            barrel = loader.loadModel(
                'phase_4/models/minigames/cogthief_game_gagTank')
            barrel.setPos(CTGG.BarrelStartingPositions[barrelIndex])
            barrel.setScale(self.BarrelScale)
            barrel.reparentTo(render)
            barrel.setTag('barrelIndex', str(barrelIndex))
            collSphere = CollisionSphere(0, 0, 0, 4)
            collSphere.setTangible(0)
            name = 'BarrelSphere-%d' % barrelIndex
            collSphereName = self.uniqueName(name)
            collNode = CollisionNode(collSphereName)
            collNode.setFromCollideMask(CTGG.BarrelBitmask)
            collNode.addSolid(collSphere)
            colNp = barrel.attachNewNode(collNode)
            handler = CollisionHandlerEvent()
            handler.setInPattern('barrelHit-%fn')
            base.cTrav.addCollider(colNp, handler)
            self.accept('barrelHit-' + collSphereName, self.handleEnterBarrel)
            nodeToHide = '**/gagMoneyTen'
            if barrelIndex % 2:
                nodeToHide = '**/gagMoneyFive'
            iconToHide = barrel.find(nodeToHide)
            if not iconToHide.isEmpty():
                iconToHide.hide()
            self.barrels.append(barrel)

        self.gameBoard = loader.loadModel(
            'phase_4/models/minigames/cogthief_game')
        self.gameBoard.find('**/floor_TT').hide()
        self.gameBoard.find('**/floor_DD').hide()
        self.gameBoard.find('**/floor_DG').hide()
        self.gameBoard.find('**/floor_MM').hide()
        self.gameBoard.find('**/floor_BR').hide()
        self.gameBoard.find('**/floor_DL').hide()
        zone = self.getSafezoneId()
        if zone == ToontownGlobals.ToontownCentral:
            self.gameBoard.find('**/floor_TT').show()
        elif zone == ToontownGlobals.DonaldsDock:
            self.gameBoard.find('**/floor_DD').show()
        elif zone == ToontownGlobals.DaisyGardens:
            self.gameBoard.find('**/floor_DG').show()
        elif zone == ToontownGlobals.MinniesMelodyland:
            self.gameBoard.find('**/floor_MM').show()
        elif zone == ToontownGlobals.TheBrrrgh:
            self.gameBoard.find('**/floor_BR').show()
        elif zone == ToontownGlobals.DonaldsDreamland:
            self.gameBoard.find('**/floor_DL').show()
        else:
            self.gameBoard.find('**/floor_TT').show()
        self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
        self.gameBoard.setScale(1.0)
        self.toonSDs = {}
        avId = self.localAvId
        toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self)
        self.toonSDs[avId] = toonSD
        toonSD.load()
        self.loadCogs()
        self.toonHitTracks = {}
        self.toonPieTracks = {}
        self.sndOof = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_dirt.ogg')
        self.sndRewardTick = base.loadSfx(
            'phase_3.5/audio/sfx/tick_counter.ogg')
        self.sndPerfect = base.loadSfx('phase_4/audio/sfx/ring_perfect.ogg')
        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.hide()
        purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
        self.jarImage = purchaseModels.find('**/Jar')
        self.jarImage.reparentTo(hidden)
        self.rewardPanel = DirectLabel(parent=hidden,
                                       relief=None,
                                       pos=(-0.173, 0.0, -0.55),
                                       scale=0.65,
                                       text='',
                                       text_scale=0.2,
                                       text_fg=(0.95, 0.95, 0, 1),
                                       text_pos=(0, -.13),
                                       text_font=ToontownGlobals.getSignFont(),
                                       image=self.jarImage)
        self.rewardPanelTitle = DirectLabel(parent=self.rewardPanel,
                                            relief=None,
                                            pos=(0, 0, 0.06),
                                            scale=0.08,
                                            text=TTLocalizer.CannonGameReward,
                                            text_fg=(0.95, 0.95, 0, 1),
                                            text_shadow=(0, 0, 0, 1))
        return
示例#27
0
TRIGGER_MASK = BitMask32.bit(3)

#** Our steering avatar
avatarNP = base.render.attachNewNode(ActorNode('yolkyNP'))
avatarNP.reparentTo(base.render)
# by the way: this time we wont use the same old smiley but a 2d guy for this snippet purposes only - it is just a plane with a texture glued on, a so 2d object then.
avatar = loader.loadModel('yolky')
avatar.reparentTo(avatarNP)
# why this? this is to have our flat puppet rendered always on top of all objects in the scene, either 2d and 3d.
avatar.setDepthWrite(True, 100)
# the rest of the stuff is as usual...
avatar.setPos(0, 0, 1)
avatar.setCollideMask(BitMask32.allOff())
avatarNP.setPos(0, 0, 15)
# The yolky collision sphere used to detect when yolky hits walls
avatarCollider = avatar.attachNewNode(CollisionNode('yolkycnode'))
avatarCollider.node().addSolid(CollisionSphere(0, 0, 0, 1))
avatarCollider.node().setFromCollideMask(WALL_MASK)
avatarCollider.node().setIntoCollideMask(BitMask32.allOff())

#** the avatar's fallout sensor - stuff already seen in former snippets, but this time we'll use it for more that to detect the fallout impact force, so we'll add another mask to look out
avatarSensor = avatarNP.attachNewNode(CollisionNode('yolkysensor'))
cs = CollisionSphere(0, 0, 0, 1.2)
avatarSensor.node().addSolid(cs)
# here the masking: note that this sensor will look for floor bashing but also for other geometries masked with TRIGGER_MASK.
avatarSensor.node().setFromCollideMask(FLOOR_MASK | TRIGGER_MASK)
avatarSensor.node().setIntoCollideMask(BitMask32.allOff())
cs.setTangible(0)

#** here's how to read the events fired by the 'sensor' while colliding with geometry we enable to collide with it.
collisionEvent.addInPattern('%fn-into')
示例#28
0
    def __fireCannonTask(self, task):
        launchTime = task.fireTime
        avId = task.avId
        if self.toonHead == None or not self.boss.state == 'BattleTwo':
            return Task.done
        startPos, startHpr, startVel, trajectory, timeOfImpact, hitWhat = self.__calcFlightResults(
            avId, launchTime)

        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:
            base.camera.reparentTo(juror)
            base.camera.setP(45.0)
            base.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
示例#29
0
#** Collision masks
FLOOR_MASK = BitMask32.bit(1)
MASK_OFF = BitMask32.allOff()

#** Our steering avatar
avatarNP = base.render.attachNewNode(ActorNode('smileyNP'))
avatarNP.reparentTo(base.render)
avatar = loader.loadModel('smiley')
avatar.reparentTo(avatarNP)
avatar.setPos(0, 0, 1)
avatar.setCollideMask(MASK_OFF)
avatarNP.setPos(0, 0, 15)

#** Stick and set the ray collider to the avatar
raygeometry = CollisionRay(0, 0, 2, 0, 0, -1)
avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay'))
avatarRay.node().addSolid(raygeometry)
# let's mask our floor FROM collider
avatarRay.node().setFromCollideMask(FLOOR_MASK)
avatarRay.node().setIntoCollideMask(MASK_OFF)

#** This is the terrain map - differently than what we used to in previous steps, the collision solids will be loaded separately. See this below.
terrain = loader.loadModel("oc3ground")
terrain.reparentTo(render)
terrain.setCollideMask(MASK_OFF)
terrain.setScale(10)

#** Let's load ands mask our collision surfaces - the task is repeated 2 times: one for a single-mesh collider and the other for the octreefied one and the two colliders data is conveniently stored in the dictionary 'floorcolliderdata', for a later usage, to show the performance difference between the two setups. The important thing to know here is that when your collision model mesh will be octreefied, the octree script will change a bit the mesh naming, changing indeed the root name, that we use here to find its geometry inside the egg file, and mask it to be recognized by the floor collision handler. In a octreefied mesh the root name will always be (at the date I'm writing and until the script will changes) "octree-root" - just be advised.

# the colliders storage
floorcolliderdata = {}
示例#30
0
    def loadModels(self):
        # load the tug of war play area
        self.playArea = loader.loadModel(
            "phase_13/models/parties/partyTugOfWar")
        # reparent to the party ground root
        self.playArea.reparentTo(self.root)

        # place the activity sign
        self.sign.reparentTo(self.playArea.find("**/TugOfWar_sign_locator"))

        # define initial positions, with index 0 being closest to the other team
        self.dockPositions = [
            [],  # left team positions
            [],  # right team positions
        ]
        for i in range(4):
            self.dockPositions[0].append(
                Point3(
                    -PartyGlobals.TugOfWarInitialToonPositionsXOffset -
                    PartyGlobals.TugOfWarToonPositionXSeparation * i,
                    0.0,
                    PartyGlobals.TugOfWarToonPositionZ,
                ))
        for i in range(4):
            self.dockPositions[1].append(
                Point3(
                    PartyGlobals.TugOfWarInitialToonPositionsXOffset +
                    PartyGlobals.TugOfWarToonPositionXSeparation * i,
                    0.0,
                    PartyGlobals.TugOfWarToonPositionZ,
                ))
        self.hopOffPositions = [
            [],  # left team positions
            [],  # right team positions
        ]
        for i in range(1, 5):
            self.hopOffPositions[
                PartyGlobals.TeamActivityTeams.LeftTeam].append(
                    self.playArea.find("**/leftTeamHopOff%d_locator" %
                                       i).getPos())
            self.hopOffPositions[
                PartyGlobals.TeamActivityTeams.RightTeam].append(
                    self.playArea.find("**/rightTeamHopOff%d_locator" %
                                       i).getPos())

        # load positions for when toons fall into the water
        for i in range(1, 5):
            pos = self.playArea.find("**/fallenToon%d_locator" % i).getPos()
            self.fallenPositions.append(pos)

        # load collision that allows toons to play the game
        # create one for each dock that lets toons join a particular team
        self.joinCollision = []
        self.joinCollisionNodePaths = []
        for i in range(len(PartyGlobals.TeamActivityTeams)):
            collShape = CollisionTube(
                PartyGlobals.TugOfWarJoinCollisionEndPoints[0],
                PartyGlobals.TugOfWarJoinCollisionEndPoints[1],
                PartyGlobals.TugOfWarJoinCollisionRadius)
            collShape.setTangible(True)

            self.joinCollision.append(
                CollisionNode("TugOfWarJoinCollision%d" % i))
            self.joinCollision[i].addSolid(collShape)
            tubeNp = self.playArea.attachNewNode(self.joinCollision[i])
            tubeNp.node().setCollideMask(ToontownGlobals.WallBitmask)
            self.joinCollisionNodePaths.append(tubeNp)
            self.joinCollisionNodePaths[i].setPos(
                PartyGlobals.TugOfWarJoinCollisionPositions[i])
        self.__enableCollisions()

        # Get the rope texture by extracting it from its model.
        ropeModel = loader.loadModel(
            "phase_4/models/minigames/tug_of_war_rope")
        self.ropeTexture = ropeModel.findTexture("*")
        ropeModel.removeNode()

        # create as many ropes as we will ever need
        for i in range(PartyGlobals.TugOfWarMaximumPlayersPerTeam * 2 - 1):
            rope = Rope(self.uniqueName("TugRope%d" % i))
            if rope.showRope:
                rope.ropeNode.setRenderMode(RopeNode.RMBillboard)
                rope.ropeNode.setThickness(0.2)
                rope.setTexture(self.ropeTexture)
                rope.ropeNode.setUvMode(RopeNode.UVDistance)
                rope.ropeNode.setUvDirection(1)
                rope.setTransparency(1)
                rope.setColor(0.89, 0.89, 0.6, 1.0)
                rope.reparentTo(self.root)
                rope.stash()
            self.tugRopes.append(rope)

        # Splash object for when toon hits the water
        self.splash = Splash.Splash(self.root)
        self.splash.setScale(2.0, 4.0, 1.0)
        pos = self.fallenPositions[0]
        self.splash.setPos(pos[0], pos[1], PartyGlobals.TugOfWarSplashZOffset)
        self.splash.hide()