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 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 _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()
