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 sphere(self, name, bitmask, pos=(0, 0, 1), radius=0.2):
col = CollisionNode(self.node.getName() + "-sphere-" + name)
shape = CollisionSphere(pos, radius)
col.add_solid(shape)
col.set_from_collide_mask(bitmask)
col.set_into_collide_mask(CollideMask.allOff())
col_node = self.node.attachNewNode(col)
handler = CollisionHandlerPusher()
handler.add_collider(col_node, self.node)
self.traverser.add_collider(col_node, handler)
return {
"collider": col,
"shape": shape,
"handler": handler,
"node": col_node
}
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 announceGenerate(self):
DistributedNode.announceGenerate(self)
self.build()
# Build collisions
self.collSphere = CollisionSphere(0, 0, 0, self.sphereRadius)
self.collSphere.setTangible(0)
self.collNode = CollisionNode(self.uniqueName('barrelSphere'))
self.collNode.setIntoCollideMask(CIGlobals.WallBitmask)
self.collNode.addSolid(self.collSphere)
self.collNodePath = self.attachNewNode(self.collNode)
self.collNodePath.hide()
self.accept('enter' + self.collNodePath.getName(),
self.__handleCollision)
self.setParent(CIGlobals.SPRender)
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 loadCollisions(self):
sphere = CollisionSphere(0, 0, 0, 1)
sphere.setTangible(0)
node = CollisionNode(self.uniqueName('collectableCollNode'))
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(self.uniqueName('collectableRayNode'))
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 load(self):
self.model = loader.loadModel('phase_5/models/props/snowball.bam')
self.model.reparentTo(self)
base.audio3d.attachSoundToObject(self.impactSound, self)
sphere = CollisionSphere(0, 0, 0, 0.35)
sphere.setTangible(0)
node = CollisionNode('snowball-coll-' + str(id(self)))
node.addSolid(sphere)
node.setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask)
self.collNP = self.attachNewNode(node)
self.collNP.setCollideMask(BitMask32(0))
self.collNP.setZ(0.35)
event = CollisionHandlerEvent()
event.set_in_pattern('%fn-into')
event.set_out_pattern('%fn-out')
base.cTrav.add_collider(self.collNP, event)
def init_sensors(self, entity, movement):
solids = movement.solids
for tag, solid in solids.items():
solid['tag'] = tag
if solid['shape'] is CollisionSphere:
shape = CollisionSphere(solid['center'], solid['radius'])
self.add_shape(entity, movement, solid, shape)
elif solid['shape'] is CollisionCapsule:
shape = CollisionCapsule(
solid['end_a'],
solid['end_b'],
solid['radius'],
)
self.add_shape(entity, movement, solid, shape)
if movement.debug:
movement.traverser.show_collisions(entity[Scene].node)
def __init__(self):
ShowBase.__init__(self)
# Create a traverser and a handler
self.cTrav = CollisionTraverser()
self.cQueue = CollisionHandlerQueue()
# Create the collision node that will store the collision
# ray solid
self.pickerNode = CollisionNode('mouseRay')
# Set bitmask for efficiency, only hit from objects with same mask
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
# Attach collision node to camera, since that is the source
self.pickerNP = camera.attachNewNode(self.pickerNode)
# Add collision solid(ray) to collision node
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
# Add collidable node(pickerNP) to the traverser
# Collisions detected when traversed will go to cQueue
self.cTrav.addCollider(self.pickerNP, self.cQueue)
# Create visible sphere
self.tmpSphere = self.loader.loadModel("models/misc/sphere")
self.tmpSphere.reparentTo(self.render)
self.tmpSphere.setColor(1, 1, 1, 1)
self.tmpSphere.setPos(0, 100, 0)
# Create collision sphere and attach to tmpSphere
cSphere = CollisionSphere(0, 0, 0, 3)
cnodePath = self.tmpSphere.attachNewNode(CollisionNode('cnode'))
# Add collision solid(sphere) to collision node
# Because tmpSphere/cSphere is child of render, which we traverse
# later, it becomes a from collider automatically, we don't
# need to addCollider since that is only for from collision nodes
cnodePath.node().addSolid(cSphere)
# Set bitmask to match the from collisionnode mask for efficiency
cnodePath.setCollideMask(BitMask32.bit(1))
# Show the collision sphere visibly, for debugging.
cnodePath.show()
# Set a custom tag on the collision node which becomes available
# inside the collision event stored in the collision handler
cnodePath.setTag('someTag', '1')
# Add task to run every frame - set collision solid(ray)
# to start at the current camera position,
self.mouseTask = taskMgr.add(self.mouseTask, 'mouseTask')
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 _explode_grenade(self, grenade_pos):
"""Explode the grenade, shot from the launcher.
Args:
grenade_pos (panda3d.core.Point3):
The position, where the sight was
when player made the shot.
"""
col_node = CollisionNode("grenade_explosion")
col_node.setFromCollideMask(NO_MASK)
col_node.setIntoCollideMask(SHOT_RANGE_MASK)
col_node.addSolid(CollisionSphere(0, 0, 0, 0.096))
base.accept("into-grenade_explosion", self._do_grenade_damage) # noqa: F821
col_np = self._model.attachNewNode(col_node)
col_np.setPos(grenade_pos)
self._hole_sprite.setPos(grenade_pos)
self._hole_sprite.wrtReparentTo(
base.world.current_block.rails_mod # noqa: F821
)
self._hole_sprite.show()
self._grenade_explosion.setPos(grenade_pos)
self._grenade_explosion.start(self._model, render) # noqa: F821
self._grenade_explosion.softStart()
self._grenade_smoke.setPos(grenade_pos)
self._grenade_smoke.start(self._model, render) # noqa: F82
self._grenade_smoke.softStart()
self._explosion_snd.play()
taskMgr.doMethodLater( # noqa: F821
1, self._grenade_explosion.softStop, "stop_grenade_explosion", extraArgs=[]
)
taskMgr.doMethodLater( # noqa: F821
2.5, self._grenade_smoke.softStop, "stop_grenade_smoke", extraArgs=[]
)
taskMgr.doMethodLater( # noqa: F821
0.1, col_np.removeNode, "remove_grenade_solid", extraArgs=[]
)
taskMgr.doMethodLater( # noqa: F821
4, self._return_hole_sprite, "hide_ground_hole",
)
def show_target(self):
self.target_select()
self.intoObject = self.tar.attachNewNode(CollisionNode('colintoNode'))
if self.table[self.trial_counter,7] == "sphere":
self.intoObject.node().addSolid(CollisionSphere(0,0,0,1))
elif self.table[self.trial_counter,7] == "cylinder":
self.intoObject.node().addSolid(CollisionTube(0,0,-2,0,0,2,1))
else:
raise NameError("No such collision type")
self.tar.show()
#hide players not related to target
for i in range(5):
if i not in self.highlighted_indices:
self.players[i].hide()
def announceGenerate(self):
DistributedToonFPSGame.announceGenerate(self)
base.camLens.setMinFov(CIGlobals.GunGameFOV / (4.0 / 3.0))
base.camLens.setFar(250)
base.localAvatar.setPythonTag('localAvatar', 1)
self.avatarBody = base.localAvatar.attachNewNode(
CollisionNode('sphereforguardeyes'))
self.avatarBody.node().addSolid(CollisionSphere(0, 0, 0, 1.2))
self.avatarBody.node().setFromCollideMask(BitMask32.allOff())
self.avatarBody.node().setIntoCollideMask(CGG.GuardBitmask)
self.gameWorld = FactorySneakWorld(self)
self.gameWorld.loadWorld()
self.gameWorld.loadJellybeanBarrels()
self.gameWorld.makeGuards()
self.gameWorld.showWorld()
self.gameWorld.setupPlayer()
self.load()
def gen_surfaceballs_cdnp(objtrm, name='cdnp_surfaceball', radius=0.01):
"""
:param obstacle:
:return:
author: weiwei
date: 20180811
"""
nsample = int(math.ceil(objtrm.area / (radius * 0.3)**2))
nsample = 120 if nsample > 120 else nsample # threshhold
samples = objtrm.sample_surface(nsample)
collision_node = CollisionNode(name)
for sglsample in samples:
collision_node.addSolid(
CollisionSphere(sglsample[0],
sglsample[1],
sglsample[2],
radius=radius))
return collision_node
def loadModel(self):
self.hill = loader.loadModel('phase_12/models/bossbotHQ/mole_hole')
self.hill.setZ(0.0)
self.hill.reparentTo(self)
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'
moleSphere = CollisionSphere(0, 0, 0, 1.0)
collNode = CollisionNode(moleColName)
collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
collNode.addSolid(moleSphere)
self.moleColNodePath = self.mole.attachNewNode(collNode)
self.moleColNodePath.stash()
self.moleColNodePath.setScale(1.0)
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 _start_shooting(self):
"""Start the machine gun shooting sequence."""
self._shot_snd.play()
taskMgr.doMethodLater(0.25, self._make_shot, "machine_gun_shoot") # noqa: F82
taskMgr.doMethodLater( # noqa: F82
4, self._stop_shooting, "stop_machine_gun_shooting"
)
col_node = CollisionNode("machine_gun_bullet")
col_node.setFromCollideMask(NO_MASK)
col_node.setIntoCollideMask(SHOT_RANGE_MASK)
col_node.addSolid(CollisionSphere(0, 0, 0, 0.005))
self._col_np = self._sight.attachNewNode(col_node)
self._shot_dirt.start(self._sight, render) # noqa: F82
self._shot_dirt.softStart()
base.accept("into-machine_gun_bullet", self._do_damage) # noqa: F82
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 __init__(self):
try:
self.__initialized
return
except:
self.__initialized = 1
NodePath.__init__(self, hidden.attachNewNode('PositionExaminer'))
self.cRay = CollisionRay(0.0, 0.0, 6.0, 0.0, 0.0, -1.0)
self.cRayNode = CollisionNode('cRayNode')
self.cRayNode.addSolid(self.cRay)
self.cRayNodePath = self.attachNewNode(self.cRayNode)
self.cRayNodePath.hide()
self.cRayBitMask = CIGlobals.FloorBitmask
self.cRayNode.setFromCollideMask(self.cRayBitMask)
self.cRayNode.setIntoCollideMask(BitMask32.allOff())
self.cSphere = CollisionSphere(0.0, 0.0, 0.0, 1.5)
self.cSphereNode = CollisionNode('cSphereNode')
self.cSphereNode.addSolid(self.cSphere)
self.cSphereNodePath = self.attachNewNode(self.cSphereNode)
self.cSphereNodePath.hide()
self.cSphereBitMask = CIGlobals.WallBitmask
self.cSphereNode.setFromCollideMask(self.cSphereBitMask)
self.cSphereNode.setIntoCollideMask(BitMask32.allOff())
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 = self.attachNewNode(self.ccLineNode)
self.ccLineNodePath.hide()
self.ccLineBitMask = CIGlobals.CameraBitmask
self.ccLineNode.setFromCollideMask(self.ccLineBitMask)
self.ccLineNode.setIntoCollideMask(BitMask32.allOff())
self.cRayTrav = CollisionTraverser('PositionExaminer.cRayTrav')
self.cRayTrav.setRespectPrevTransform(False)
self.cRayQueue = CollisionHandlerQueue()
self.cRayTrav.addCollider(self.cRayNodePath, self.cRayQueue)
self.cSphereTrav = CollisionTraverser('PositionExaminer.cSphereTrav')
self.cSphereTrav.setRespectPrevTransform(False)
self.cSphereQueue = CollisionHandlerQueue()
self.cSphereTrav.addCollider(self.cSphereNodePath, self.cSphereQueue)
self.ccLineTrav = CollisionTraverser('PositionExaminer.ccLineTrav')
self.ccLineTrav.setRespectPrevTransform(False)
self.ccLineQueue = CollisionHandlerQueue()
self.ccLineTrav.addCollider(self.ccLineNodePath, self.ccLineQueue)
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 pieThrow(self, avId, timestamp, heading, pos, power):
toon = self.activity.getAvatar(avId)
if toon is None:
return
else:
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
def setupElevator(self):
collisionRadius = ElevatorData[self.type]['collRadius']
self.elevatorSphere = CollisionSphere(0, 5, 0, collisionRadius)
self.elevatorSphere.setTangible(0)
self.elevatorSphereNode = CollisionNode(
self.uniqueName('elevatorSphere'))
self.elevatorSphereNode.setIntoCollideMask(CIGlobals.WallBitmask)
self.elevatorSphereNode.addSolid(self.elevatorSphere)
self.elevatorSphereNodePath = self.getElevatorModel().attachNewNode(
self.elevatorSphereNode)
self.elevatorSphereNodePath.reparentTo(self.getElevatorModel())
self.openDoors = getOpenInterval(self, self.getLeftDoor(),
self.getRightDoor(), self.openSfx,
None, self.type)
self.closeDoors = getCloseInterval(self, self.getLeftDoor(),
self.getRightDoor(), self.closeSfx,
None, self.type)
self.closeDoors = Sequence(self.closeDoors,
Func(self.onDoorCloseFinish))
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() * 1.1
# Create a collision sphere and name it something understandable.
collSphereStr = 'CollisionHull{0}_{1}'.format(self.collCount, obj.name)
self.collCount += 1
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)
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 __init__(self, n=1, bins=1):
#index = md()
#def get_index():
#return index
#indexMan.register('index',get_index)
#self.iman = indexMan(('127.0.0.1',5000),authkey='none')
#self.iman.start()
index = {}
#index_counter = Counter(0,1)
collideRoot = render.attachNewNode('collideRoot')
bases = [
np.cumsum(np.random.randint(-1, 2, (n, 3)), axis=0)
for i in range(bins)
]
type_ = GeomPoints
runs = []
for base in bases:
runs.append(convertToGeom(index_counter, base, type_))
for nodes in runs:
for node, idx in nodes(): #FIXME stupid
nd = render.attachNewNode(node)
index.update(idx) #FIXME this is nasty
print(idx)
for uid, list_ in index.items():
#TODO to change the color of a selected node we will need something a bit more ... sophisticated
#parent = list_[1][0]
if list_ == None:
continue
cNode = collideRoot.attachNewNode(
CollisionNode('collider %s' %
uid)) #ultimately used to index??
cNode.node().addSolid(CollisionSphere(0, 0, 0, .5))
cNode.node().setIntoCollideMask(BitMask32.bit(BITMASK_COLL_CLICK))
cNode.setPos(*list_[0])
cNode.setPythonTag('uid', uid)
cNode.show()
list_[
2] = cNode #FIXME this is inconsistent and the 'uid' means different things in different contexts!
print(index_counter.value)
def initCollisions(self):
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
self.cTrav.showCollisions(self.render)
# Initialize the Pusher collision handler.
self.pusher = CollisionHandlerFloor()
### player
# Create a collsion node for this object.
playerNode = CollisionNode('player')
playerNode.addSolid(CollisionSphere(0, 0, 0, 1))
# Attach the collision node to the object's model.
self.playerC = self.fpscamera.player.attachNewNode(playerNode)
# Set the object's collision node to render as visible.
self.playerC.show()
def __init__(self, pos, modelName, modelAnims, maxHealth, maxSpeed, colliderName):
self.actor = Actor(modelName, modelAnims)
self.actor.reparentTo(render)
self.actor.setPos(pos)
self.maxHealth = maxHealth
self.health = maxHealth
self.maxSpeed = maxSpeed
self.velocity = Vec3(0, 0, 0)
self.acceleration = 300.0
self.walking = False
colliderNode = CollisionNode(colliderName)
colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3))
self.collider = self.actor.attachNewNode(colliderNode)
self.collider.setPythonTag("owner", self)
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 loadCollision(self):
collTube = CollisionTube(0.0, 0.0, self.z, 0.0, 0.0, self.z, 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, self.z, 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 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')
