def __init__(self):
"""initialise the engine"""
ShowBase.__init__(self)
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0,-a,a+3)#80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock=ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.monsters = []
self.accept('c',self._create)
base.enableParticles()
def enterPlay(self):
self.notify.debug('enterPlay')
self.startGameWalk()
self.spawnUpdateSuitsTask()
self.accept('control', self.controlKeyPressed)
self.pieHandler = CollisionHandlerEvent()
self.pieHandler.setInPattern('pieHit-%fn')
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)
def set_controls(self):
"""Configure common game controls.
Configure major keys, collisions system
and controls to manipulate characters.
"""
base.accept("f1", self._show_keys) # noqa: F821
base.accept("escape", base.main_menu.show) # noqa: F821
base.accept("r", self._show_char_relations) # noqa: F821
base.accept("m", base.world.rails_scheme.show) # noqa: F821
base.accept("j", base.journal.show) # noqa: F821
# configure mouse collisions
col_node = CollisionNode("mouse_ray")
col_node.setIntoCollideMask(NO_MASK)
col_node.setFromCollideMask(MOUSE_MASK)
self._mouse_ray = CollisionRay()
col_node.addSolid(self._mouse_ray)
# set common collisions handler
handler = CollisionHandlerEvent()
handler.addInPattern("%fn-into")
handler.addAgainPattern("%fn-again")
handler.addOutPattern("%fn-out")
self.traverser = CollisionTraverser("traverser")
self.traverser.addCollider(
base.cam.attachNewNode(col_node), handler # noqa: F821
)
self.set_mouse_events()
taskMgr.doMethodLater(0.03, self._collide_mouse, "collide_mouse") # noqa: F821
taskMgr.doMethodLater(0.04, self._traverse, name="main_traverse") # noqa: F821
def postInit(self):
#
# initialize game content
#
# camera
base.camLens.setNearFar(1.0, 10000)
base.camLens.setFov(75)
a = 33
base.camera.setPos(0, -a, a + 3) #80)
# collision
base.cTrav = CollisionTraverser("base collision traverser")
base.cHandler = CollisionHandlerEvent()
base.cPusher = CollisionHandlerPusher()
base.cQueue = CollisionHandlerQueue()
base.globalClock = ClockObject.getGlobalClock()
base.cHandler.addInPattern('%fn-into-%in')
base.cHandler.addOutPattern('%fn-out-%in')
base.cHandler.addAgainPattern('%fn-again-%in')
# ai init
base.AIworld = AIWorld(render)
# 3d manager
base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
# manager
self.archiveManager = ArchiveManager()
self.mapManager = MapManager()
self.initHeroInfo = None
# Lock
self.lock = threading.Lock()
self.gameThread = None
self.filters = CommonFilters(base.win, base.cam)
# UI
self.menu = Menu()
self.option = Option()
self.archive = Archive()
self.death = Death()
# self.oobe()
#self.Archive_status = 0
# self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg")
# self.menuMusic.setLoop(True)
# self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg")
# self.fightMusic.setLoop(True)
# base.audio3d = Audio3DManager(base.sfxManagerList[0], camera)
self.titleVideo, self.titleCard = loadVideo('title.mp4')
self.isInited = False
self.isSkip = False
self.isRenew = False
#
# Event handling
#
self.accept("escape", self.__escape)
#
# Start with the menu
#
self.request("Menu")
def __init__(self):
ShowBase.__init__(self)
# Override defaults
self.disableMouse()
self.setBackgroundColor(VBase3(160, 200, 150) / 255.0)
self.setFrameRateMeter(True)
# Lights
dlight = DirectionalLight("dlight")
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(180.0, -70.0, 0)
self.render.setLight(dlnp)
alight = AmbientLight("alight")
alnp = self.render.attachNewNode(alight)
alight.setColor(VBase4(0.4, 0.4, 0.4, 1))
self.render.setLight(alnp)
# Collision traverser
self.cTrav = CollisionTraverser("collisionTraverser")
#self.cTrav.showCollisions(self.render)
# Collision handlers
self.carCollisionHandler = CollisionHandlerEvent()
self.carCollisionHandler.addInPattern("%fn-into-%in")
# Camera controls
self.cameraController = CameraController(self, 400, math.pi / 4.0,
math.pi / 4.0)
#self.cameraController = CameraController(self, 300, -math.pi, math.pi / 4.0)
# Load the track
#self.track = self.loader.loadModel("models/trackMotegi")
self.track = self.loader.loadModel("models/trackValencia")
checkpointsCollision = self.track.find("checkpoints").node()
checkpointsCollision.setIntoCollideMask(BitMask32(0xF0))
self.numCheckpoints = checkpointsCollision.getNumSolids()
self.track.reparentTo(self.render)
# Load the car
#self.car = KeyboardCar(self)
self.car = NeuralNetworkCar(self)
self.cameraController.follow(self.car.getNodePath())
#self.cameraController.setTarget(self.car.getNodePath())
# Reposition the car
#self.car.getNodePath().setH(180.0)
# Register car collisions with track
self.cTrav.addCollider(self.car.carCollider, self.carCollisionHandler)
self.accept("carCollider-into-trackCollision", self.car.onCrash)
self.accept("carCollider-into-checkpoints", self.car.onCheckpoint)
# State logger
self.loggingActive = False
self.log = []
self.accept("l", self.toggleStateLogger)
def __init__(self):
#--Collision Handler------------------------------------------------------
self.collHandler = CollisionHandlerEvent()
self.collHandler.addInPattern('%fn-into-%in')
base.cTrav = CollisionTraverser('world traverser')
#--Mouse Control----------------------------------------------------------
base.disableMouse()
self.properties = WindowProperties()
self.properties.setCursorHidden(True)
base.win.requestProperties(self.properties)
#--Register Hud Elements--------------------------------------------------
self.instruction1 = self.addInstruction("[click] to Shoot", 2)
self.instruction2 = self.addInstruction("[a] to accelerate", 1)
self.instruction3 = self.addInstruction("[esc] to quit", 0)
self.scoreHud = self.addHudElement("", 0)
self.accuracy = self.addHudElement("", 1)
self.speedHud = self.addHudElement("", 2)
self.bigHud = OnscreenText(text="",
style=1,
fg=(1, 1, 1, 1),
pos=(0, 0),
align=TextNode.ACenter,
scale=.1)
#--Load Objects and Models------------------------------------------------
self.ship = Ship(self.collHandler)
self.loadSkyBox()
game.camera.reparentTo(self.ship.getModel())
#--Start Game-------------------------------------------------------------
self.asteroids = []
self.resetGame()
#--Controls --------------------------------------------------------------
self.keysDown = {'a': 0}
self.controlTask = taskMgr.add(self.gameLoop, "game-control-task")
self.controlTask.lastTime = 0
self.accept("escape", sys.exit, [0])
self.accept("a", self.keyDown, ['a'])
self.accept("a-up", self.keyUp, ['a'])
self.accept("mouse1", self.shoot)
self.accept("space", self.shoot)
self.accept("resetgame", self.gameOver)
if (DEBUG_CONTROLS):
self.accept("0", self.ship.stop)
self.accept("9", self.ship.getModel().setHpr, [0, 0, 0])
#--Register CollisionEvent Handlers---------------------------------------
self.accept('asteroid-into-bullet', self.bulletAsteroidCollision)
def __init__(self, showbase, usersData, gameData):
DirectObject.__init__(self)
self.showbase = showbase
self.usersData = usersData
self.gameData = gameData
random.seed(self.gameData.randSeed)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.world = World(showbase)
self.ambientLight = showbase.render.attachNewNode(
AmbientLight("ambientLight"))
# Set the color of the ambient light
self.ambientLight.node().setColor((.1, .1, .1, 1))
# add the newly created light to the lightAttrib
# showbase.render.setLight(self.ambientLight)
self.spotlight = None
numberOfPlayers = len(self.usersData)
for index, user in enumerate(self.usersData):
user.centipede = Centipede(showbase, index, numberOfPlayers,
self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.spotlight = self.centipede.head.attachNewNode(
PointLight("playerSpotlight"))
self.spotlight.setPos(LVector3(0, 0, 8))
# Now we create a spotlight. Spotlights light objects in a given cone
# They are good for simulating things like flashlights
self.spotlight.node().setAttenuation(
LVector3(.025, 0.0005, 0.0001))
self.spotlight.node().setColor((0.35, 0.35, .35, 1))
self.spotlight.node().setSpecularColor((0.01, 0.01, 0.01, 1))
showbase.render.setLight(self.spotlight)
self.perPixelEnabled = True
self.shadowsEnabled = True
#if self.spotlight:
# self.spotlight.node().setShadowCaster(True, 512, 512)
showbase.render.setShaderAuto()
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
def __init__(self):
super().__init__(self)
self.scene = self.loader.loadModel("./models/world.egg")
self.scene.reparentTo(self.render)
base.cTrav = CollisionTraverser()
self.collisionHandlerEvent = CollisionHandlerEvent()
base.enableParticles()
#base.messenger.toggleVerbose()
#self.collisionHandlerEvent.addInPattern('from-%in')
self.collisionHandlerEvent.addInPattern('into-%in')
self.collisionHandlerEvent.addOutPattern('outof-%in')
self.player = self.scene.find("player")
self.enemy = self.scene.find("enemy1")
self.player.setPythonTag("ObjectController",
Player(self.player, collisionMask=0x4))
self.building_enemy = self.scene.find("building_enemy")
#self.player.setPos(self.scene, 0,0,5)
self.camera.setPos(self.render, 0, -50, 100)
self.taskMgr.add(self.update, "update")
self.accept('into-collision_enemy', self.crash)
self.accept('into-collision_player', self.crash)
self.accept('into-collision_plane', self.crash)
base.cTrav.addCollider(self.scene.find("player/collision**"),
self.collisionHandlerEvent)
base.cTrav.addCollider(self.scene.find("enemy1/collision**"),
self.collisionHandlerEvent)
base.cTrav.addCollider(self.scene.find("basePlane/collision**"),
self.collisionHandlerEvent)
#base.cTrav.showCollisions(self.render)
InputManager.initWith(self, [
InputManager.arrowUp, InputManager.arrowDown,
InputManager.arrowRight, InputManager.arrowLeft, InputManager.keyS,
InputManager.keyA, InputManager.space, InputManager.keyX,
InputManager.keyV
])
self.rails = self.scene.attachNewNode("rails")
self.rails.setPos(self.scene, 0, 0, 0)
self.rails_y = 0
self.player.reparentTo(self.rails)
self.player.setPos(self.rails, 0, 20, 0)
#self.createStaticEnemy(self.building_enemy , -100 ,500, 0 )
self.createStaticEnemy(self.building_enemy, 200, 850, 0)
self.createStaticEnemy(self.building_enemy, -100, 1000, 0)
self.createDynamicEnemy(self.enemy, -80, 500, 20, -200, 500, 20)
def setupCollisions(self):
sphere = CollisionSphere(0, 0, 0, 0.1)
collnode = CollisionNode('bulletCollNode-' + str(id(self)))
collnode.addSolid(sphere)
self.collnp = self.bullet.attachNewNode(collnode)
self.collnp.setCollideMask(BitMask32(0))
self.collnp.node().setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask | CIGlobals.EventBitmask)
event = CollisionHandlerEvent()
event.setInPattern('%fn-into')
event.setOutPattern('%fn-out')
base.cTrav.addCollider(self.collnp, event)
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def buildCollisions(self, entity):
pieSphere = CollisionSphere(0, 0, 0, 1)
pieSensor = CollisionNode('gagSensor')
pieSensor.addSolid(pieSphere)
pieNP = entity.attachNewNode(pieSensor)
pieNP.setCollideMask(BitMask32(0))
pieNP.node().setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask)
event = CollisionHandlerEvent()
event.set_in_pattern('%fn-into')
event.set_out_pattern('%fn-out')
base.cTrav.add_collider(pieNP, event)
self.avatar.acceptOnce('gagSensor-into', self.onCollision)
def buildCollisions(self):
gagSph = CollisionSphere(0, 1.5, 0, 2)
gagSensor = CollisionNode('gagSensor')
gagSensor.addSolid(gagSph)
sensorNP = self.gag.attachNewNode(gagSensor)
sensorNP.setCollideMask(BitMask32(0))
sensorNP.node().setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask)
event = CollisionHandlerEvent()
event.set_in_pattern("%fn-into")
event.set_out_pattern("%fn-out")
base.cTrav.addCollider(sensorNP, event)
self.avatar.acceptOnce('gagSensor-into', self.onCollision)
def buildCollisions(self):
pieSphere = CollisionSphere(0, 0, 0, 1)
pieSensor = CollisionNode('turretGagSensor' + str(id(self)))
pieSensor.addSolid(pieSphere)
pieNP = self.gag.attachNewNode(pieSensor)
pieNP.setCollideMask(BitMask32(0))
pieNP.node().setFromCollideMask(CIGlobals.WallBitmask
| CIGlobals.FloorBitmask)
event = CollisionHandlerEvent()
event.set_in_pattern('%fn-into')
event.set_out_pattern('%fn-out')
base.cTrav.addCollider(pieNP, event)
def __init__(self):
"""Setup this app."""
ShowBase.__init__(self)
#Setup window
wnd_props = WindowProperties()
wnd_props.set_title("Neo Impressive Title")
#wnd_props.set_origin(0, 0)
wnd_props.set_size(1024, 768)
self.win.request_properties(wnd_props)
self.set_background_color(0, .5, 1, 1)
#Init GUI sub-system
self.gui = GUI(self)
self.gui.run()
#Init app state
self.state = APP_STATE_LOGO
self.logo_delay = 600
#Start title music
self.title_music = loader.loadMusic("./data/sounds/title.ogg")
self.title_music.set_loop(True)
self.title_music.play()
#Setup collision detection
self.cTrav = CollisionTraverser()
self.portal_handler = CollisionHandlerEvent()
self.portal_handler.add_in_pattern("%fn-entered-%in")
#Init other sub-systems
self.cam_mgr = CameraManager()
self.world_mgr = WorldManager()
#Setup lighting
self.ambient = AmbientLight("Ambient Light")
self.ambient.set_color(Vec4(.5, .5, .5, 1))
self.ambient_np = self.render.attach_new_node(self.ambient)
self.render.set_light(self.ambient_np)
self.sun = DirectionalLight("Sun")
self.sun_np = self.render.attach_new_node(self.sun)
self.sun_np.set_p(-135)
self.render.set_light(self.sun_np)
#Setup auto-shaders
self.render.set_shader_auto()
#Debug stats
#self.messenger.toggle_verbose()
PStatClient.connect()
def __init__(self):
# start Panda3d
base = ShowBase()
# CollisionTraverser instance must be attached to base,
# and must be called cTrav
base.cTrav = CollisionTraverser()
self.cHand = CollisionHandlerEvent()
self.cHand.addInPattern('into-%in')
# load smiley, which we will control
# notice this is a little trickery. If we parent everything except smiley
# to the camera, and the player is controlling the camera, then everything
# stays fixed in the same place relative to the camera, and when the camera
# moves, the player is given the illusion that he is moving smiley, rather than
# the camera and the rest of the scene.
self.smiley = base.loader.loadModel('smiley')
self.smiley.reparentTo(render)
self.smiley.setName('Smiley')
# Setup a collision solid for this model. Our initCollisionSphere method returns
# the cNodepath and the string representing it. We will use the cNodepath for
# adding to the traverser, and the string to accept it for event handling.
#sColl = self.initCollisionSphere(self.smiley)
sColl = self.initCollisionSphere(self.smiley, True)
print 'smiley', sColl[0]
print 'smiley', sColl[1]
# Add this object to the traverser.
base.cTrav.addCollider(sColl[0], self.cHand)
# load frowney
self.frowney = base.loader.loadModel('frowney')
self.frowney.setName('Frowney')
self.frowney.reparentTo(camera)
# Setup a collision solid for this model.
fColl = self.initCollisionSphere(self.frowney, True)
#print 'frowney', fColl[0]
#print 'frowney', fColl[1]
# Add this object to the traverser.
base.cTrav.addCollider(fColl[0], self.cHand)
# Accept the events sent by the collisions.
# smiley is the object we are 'moving', so by convention
# it is the from object.
# If we instead put smiley as the into object here,
# it would work fine, but then smiley would disappear
# when we collided them.
self.accept('into-' + fColl[1], self.collide)
# set the initial positions of smiley and frowney
self.set_initial_positions()
def __initCollisions(self):
collSphere = CollisionSphere(0, 0, 0, Globals.PlayerCollisionRadius)
collSphere.setTangible(0)
self.mazeCollisionName = Globals.LocalPlayerCollisionName
collNode = CollisionNode(self.mazeCollisionName)
collNode.addSolid(collSphere)
collNodePath = self.toon.attachNewNode(collNode)
collNodePath.hide()
handler = CollisionHandlerEvent()
handler.addInPattern('%fn-into-%in')
base.cTrav.addCollider(collNodePath, handler)
self.handler = handler
self._collNodePath = collNodePath
def pieCollisions(self):
pss = CollisionSphere(0, 0, 0, 1)
psnode = CollisionNode('projectilePieSensor' + str(id(self)))
psnode.add_solid(pss)
self.psnp = self.pie.attach_new_node(psnode)
self.psnp.set_collide_mask(BitMask32(0))
self.psnp.node().set_from_collide_mask(CIGlobals.WallBitmask
| CIGlobals.FloorBitmask)
event = CollisionHandlerEvent()
event.set_in_pattern("%fn-into")
event.set_out_pattern("%fn-out")
base.cTrav.add_collider(self.psnp, event)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
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 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 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 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 test_collision_handler_event_pickle():
from panda3d.core import CollisionHandlerEvent
handler = CollisionHandlerEvent()
handler.add_in_pattern("abcdefg")
handler.add_in_pattern("test")
handler.add_again_pattern("again pattern")
handler.add_again_pattern("another again pattern")
handler.add_out_pattern("out pattern")
handler = loads(dumps(handler, -1))
assert tuple(handler.in_patterns) == ("abcdefg", "test")
assert tuple(handler.again_patterns) == ("again pattern",
"another again pattern")
assert tuple(handler.out_patterns) == ("out pattern", )
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 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 __init__(self):
# Initialize the traverser.
base.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
# Make a variable to store the unique collision string count.
self.collCount = 0
# Load a model. Reparent it to the camera so we can move it.
s = base.loader.loadModel('smiley')
s.reparentTo(base.camera)
s.setPos(0, 25, 0)
# Setup a collision solid for this model.
sColl = self.initCollisionSphere(s, True)
# Add this object to the traverser.
base.cTrav.addCollider(sColl[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept('into-' + sColl[1], self.collide3)
self.accept('outof-' + sColl[1], self.collide4)
print(sColl[1])
# Load another model.
t = base.loader.loadModel('smiley')
t.reparentTo(base.render)
t.setPos(5, 25, 0)
# Setup a collision solid for this model.
tColl = self.initCollisionSphere(t, True)
# Add this object to the traverser.
base.cTrav.addCollider(tColl[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept('into-' + tColl[1], self.collide)
self.accept('outof-' + tColl[1], self.collide2)
print(tColl[1])
print("WERT")
def swordHitEnemy(self, task):
# When the sword collides with enemy, enemy dies
for enemy in self.enemies:
self.playerKill = CollisionHandlerEvent()
base.cTrav.addCollider(enemy.collider, self.playerKill)
self.playerKill.addInPattern('%fn-into-%in')
# perform the task
self.kill = DirectObject()
self.kill.accept('enemy' + str(enemy.numb) + '-into-swordCollider',
enemy.killEnemy)
self.swordHit = DirectObject()
self.swordHit.accept(
'enemy' + str(enemy.numb) + '-into-swordCollider',
self.swordHitSound)
if not enemy.isAlive:
self.enemies.remove(enemy)
return task.cont
def __init__(self, id, toon, game, guiMgr):
CogdoMazePlayer.__init__(self, id, toon)
self.disableGagCollision()
self.game = game
self.maze = self.game.maze
self._guiMgr = guiMgr
self.cameraMgr = CogdoMazeCameraManager(self.toon, self.maze, camera,
render)
self._proximityRadius = self.maze.cellWidth * Globals.CameraRemoteToonRadius
orthoDrive = OrthoDrive(
Globals.ToonRunSpeed,
maxFrameMove=self.maze.cellWidth / 2,
customCollisionCallback=self.maze.doOrthoCollisions,
wantSound=True)
self.orthoWalk = OrthoWalk(orthoDrive)
self._audioMgr = base.cogdoGameAudioMgr
self._getMemoSfx = self._audioMgr.createSfx('getMemo',
source=self.toon)
self._waterCoolerFillSfx = self._audioMgr.createSfx('waterCoolerFill',
source=self.toon)
self._hitByDropSfx = self._audioMgr.createSfx('toonHitByDrop',
source=self.toon)
self._winSfx = self._audioMgr.createSfx('win')
self._loseSfx = self._audioMgr.createSfx('lose')
self.enabled = False
self.pickupCount = 0
self.numEntered = 0
self.throwPending = False
self.coolDownAfterHitInterval = Sequence(
Wait(Globals.HitCooldownTime),
Func(self.setInvulnerable, False),
name='coolDownAfterHitInterval-%i' % self.toon.doId)
self.invulnerable = False
self.gagHandler = CollisionHandlerEvent()
self.gagHandler.addInPattern('%fn-into-%in')
self.exited = False
self.hints = {
'find': False,
'throw': False,
'squashed': False,
'boss': False,
'minion': False
}
self.accept('control', self.controlKeyPressed)
def startActivity(self, timestamp):
self.pieHandler = CollisionHandlerEvent()
self.pieHandler.setInPattern('pieHit-%fn')
if self.player is not None:
self.player.resetScore()
self.hideTeamFlags(self.player.team)
for player in list(self.players.values()):
self.finishToonIval(player.toon.doId)
player.enable()
for cog in self.cogManager.cogs:
cog.request('Active', timestamp)
for ival in self.pieIvals:
if ival.isPlaying():
ival.finish()
self.pieIvals = []
return
