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 __init__(self, showbase, usersData, gameData):
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)
for user in self.usersData:
user.centipede = Centipede(showbase, len(self.usersData),
self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
self.ticks = 0
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 __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 __init__(self, model, world, space, pos):
self.model = model
self.world = world
self.space = space
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.addBox(pos)
self.isCollected = False
Coin.collectable += 1
def __init__(self):
self.line_dir = NodePath()
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.model = loader.loadModel("../models/chest.egg")
self.model_node = NodePath("sdfafd")
self.model.reparentTo(self.model_node)
self.model_node.reparentTo(render)
#
# self.text_node = TextNode("battle_text")
# self.text_node.setText("TEXTYTEXTYTEXTTEXT")
# self.text_node_path = render.attachNewNode(self.text_node)
# self.text_node_path.reparentTo(render)
# self.text_node_path.setPos(0,0,4)
# self.text_node_path.setHpr(0,0,0)
# self.text_node_path.setScale(1)
# #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha)
# self.text_node.setTextColor((1,1,1,1))
# self.text_node.setAlign(TextNode.ALeft)
self.placement_ghost = EditorObjects.PlacementGhost(
0, "tower", base.object_scale)
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
self.input_init()
self.pickable = None
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 init_collisions(self):
base.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerEvent()
pickerNode = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(pickerNode)
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
pickerNode.setTag("rays","ray1")
base.cTrav.addCollider(pickerNPos, self.cHandler)
def initCollisionTest(self):
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
base.cTrav = CollisionTraverser('test name')
if False:
base.cTrav.showCollisions(render)
cName = 'BallCollNode'
cSphere = CollisionSphere(0, 0, 0, 1.0)
cNode = CollisionNode(cName)
cNode.addSolid(cSphere)
cNodePath = self.ball.modelNode.attachNewNode(cNode)
base.cTrav.addCollider(cNodePath, self.collHandEvent)
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 __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 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 loadGame(self):
self.camera.setPos(CposX, CposY, CposZ)
self.camera.setHpr(0,0,0)
#for j in range(0, 100):
#self.environ[j] = self.loader.loadModel("CityTerrain/CityTerrain")
#self.environ[j].reparentTo(self.render)
#self.environ[j].setPos(-8,42 + 210*j,0)
#self.environ[j].setScale(0.25,0.25,0.25)
self.accept("arrow_up-repeat", self.setKey, ["forward", 1])
self.accept("arrow_down-repeat", self.setKey, ["slow", 1])
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
base.cTrav = CollisionTraverser()
self.collHandEvent = CollisionHandlerEvent()
self.collCount=0
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
sColl = self.initCollisionSphere(self.environ1, True)
base.cTrav.addCollider(sColl[0], self.collHandEvent)
for child in render.getChildren():
if child != camera and child != self.environ2 and child!= self.environ4 and child != self.BS and child!= self.model and child!= self.barn and child!= self.barn1 and child!= self.barn2 and child!= self.barn3 and child!= self.barn5:
#print child
tColl = self.initCollisionSphere(child, True)
base.cTrav.addCollider(tColl[0], self.collHandEvent)
self.accept('into-' + tColl[1] , self.collide)
## for m in range(0,100):
## tgrb= self.initCollisionSphere(self.grb[i], True)
## base.cTrav.addCollider(tgrb[0], self.collHandEvent)
## self.accept('into-' + tgrb[1], self.collide)
##
## for n in range(0,100):
## tobs= self.initCollisionSphere(self.obs[i], True)
## base.cTrav.addCollider(tobs[0], self.collHandEvent)
## self.accept('into-' + tobs[1], self.collide)
self.taskMgr.add(self.move, "moveTask")
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 = loader.loadModel('smiley')
s.reparentTo(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 = loader.loadModel('smiley')
t.reparentTo(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 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 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 = []
def createCatchCollisions(self):
radius = 0.7
handler = CollisionHandlerEvent()
handler.setInPattern('ltCatch%in')
self.ltLegsCollNode = CollisionNode('catchLegsCollNode')
self.ltLegsCollNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
self.ltHeadCollNode = CollisionNode('catchHeadCollNode')
self.ltHeadCollNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
self.ltLHandCollNode = CollisionNode('catchLHandCollNode')
self.ltLHandCollNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
self.ltRHandCollNode = CollisionNode('catchRHandCollNode')
self.ltRHandCollNode.setCollideMask(PartyGlobals.CatchActivityBitmask)
legsCollNodepath = base.localAvatar.attachNewNode(self.ltLegsCollNode)
legsCollNodepath.hide()
head = base.localAvatar.getHeadParts().getPath(2)
headCollNodepath = head.attachNewNode(self.ltHeadCollNode)
headCollNodepath.hide()
lHand = base.localAvatar.getLeftHands()[0]
lHandCollNodepath = lHand.attachNewNode(self.ltLHandCollNode)
lHandCollNodepath.hide()
rHand = base.localAvatar.getRightHands()[0]
rHandCollNodepath = rHand.attachNewNode(self.ltRHandCollNode)
rHandCollNodepath.hide()
base.localAvatar.cTrav.addCollider(legsCollNodepath, handler)
base.localAvatar.cTrav.addCollider(headCollNodepath, handler)
base.localAvatar.cTrav.addCollider(lHandCollNodepath, handler)
base.localAvatar.cTrav.addCollider(lHandCollNodepath, handler)
if self.ShowToonSpheres:
legsCollNodepath.show()
headCollNodepath.show()
lHandCollNodepath.show()
rHandCollNodepath.show()
self.ltLegsCollNode.addSolid(CollisionSphere(0, 0, radius, radius))
self.ltHeadCollNode.addSolid(CollisionSphere(0, 0, 0, radius))
self.ltLHandCollNode.addSolid(
CollisionSphere(0, 0, 0, 2 * radius / 3.0))
self.ltRHandCollNode.addSolid(
CollisionSphere(0, 0, 0, 2 * radius / 3.0))
self.toonCollNodes = [
legsCollNodepath, headCollNodepath, lHandCollNodepath,
rHandCollNodepath
]
def __init__(self):
from pandac.PandaModules import CollisionHandlerFloor, CollisionHandlerPusher, CollisionHandlerEvent, CollisionTraverser
from pandac.PandaModules import DirectionalLight, AmbientLight, VBase4
ShowBase.__init__(self)
self.sky = self.loader.loadModel('models/sky-sphere')
self.sky.reparentTo(self.render)
self.stage = self.loader.loadModel('models/test-collide')
self.stage.reparentTo(self.render)
self.floor = self.stage.findAllMatches('**/=CollideType=floor')
self.floor.setCollideMask(FLOOR_MASK)
self.obstacles = self.stage.findAllMatches('**/=CollideType=obstacle')
if self.obstacles:
self.obstacles.setCollideMask(OBSTACLE_MASK)
self.zones = self.stage.findAllMatches('**/=CollideType=zone')
if self.zones:
self.zones.setCollideMask(ZONE_MASK)
self.create_stanchions()
# Character rig, which allows camera to follow character
self.char_rig = self.stage.attachNewNode('char_rig')
self.active_char = Character('mainchar', self.char_rig)
self.cam.reparentTo(self.char_rig)
self.cam.setPos(0.5, -3, 1.5)
self.cam.lookAt(0.5, 0, 1.5)
self.light = DirectionalLight('dlight')
self.light.setColor(VBase4(0.3, 0.28, 0.26, 1.0))
self.lightNP = self.stage.attachNewNode(self.light)
self.lightNP.setHpr(-75, -45, 0)
self.stage.setLight(self.lightNP)
self.amblight = AmbientLight('amblight')
self.amblight.setColor(VBase4(0.7, 0.68, 0.66, 1.0))
self.amblightNP = self.stage.attachNewNode(self.amblight)
self.stage.setLight(self.amblightNP)
self.accept('w', self.active_char.begin_forward)
self.accept('a', self.active_char.begin_left)
self.accept('s', self.active_char.begin_backward)
self.accept('d', self.active_char.begin_right)
self.accept('w-up', self.active_char.end_forward)
self.accept('a-up', self.active_char.end_left)
self.accept('s-up', self.active_char.end_backward)
self.accept('d-up', self.active_char.end_right)
self.taskMgr.add(self.active_char.MoveTask, 'MoveTask')
self.look = False
self.prev_pos = None
self.accept('mouse2', self.begin_look)
self.accept('mouse2-up', self.end_look)
self.accept('mouse3', self.active_char.begin_spin)
self.accept('mouse3-up', self.active_char.end_spin)
self.taskMgr.add(self.MouseTask, 'MouseTask')
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(self.active_char.actor_from_floor,
self.char_rig)
self.wall_handler = CollisionHandlerPusher()
self.wall_handler.addCollider(self.active_char.actor_from_obstacle,
self.char_rig)
self.zone_handler = CollisionHandlerEvent()
self.zone_handler.addInPattern('%fn-into')
self.zone_handler.addOutPattern('%fn-out')
def foo(entry):
print 'You are in the zone'
def bar(entry):
print 'You are not in the zone'
self.accept('blockchar_zone-into', foo)
self.accept('blockchar_zone-out', bar)
self.cTrav = CollisionTraverser('main traverser')
self.cTrav.setRespectPrevTransform(True)
self.cTrav.addCollider(self.active_char.actor_from_floor,
self.floor_handler)
self.cTrav.addCollider(self.active_char.actor_from_obstacle,
self.wall_handler)
self.cTrav.addCollider(self.active_char.actor_from_zone,
self.zone_handler)
def load(self):
self.notify.debug('load')
DistributedMinigame.load(self)
self.music = base.loadMusic('phase_4/audio/bgm/MG_CogThief.ogg')
self.initCogInfo()
for barrelIndex in xrange(CTGG.NumBarrels):
barrel = loader.loadModel(
'phase_4/models/minigames/cogthief_game_gagTank')
barrel.setPos(CTGG.BarrelStartingPositions[barrelIndex])
barrel.setScale(self.BarrelScale)
barrel.reparentTo(render)
barrel.setTag('barrelIndex', str(barrelIndex))
collSphere = CollisionSphere(0, 0, 0, 4)
collSphere.setTangible(0)
name = 'BarrelSphere-%d' % barrelIndex
collSphereName = self.uniqueName(name)
collNode = CollisionNode(collSphereName)
collNode.setFromCollideMask(CTGG.BarrelBitmask)
collNode.addSolid(collSphere)
colNp = barrel.attachNewNode(collNode)
handler = CollisionHandlerEvent()
handler.setInPattern('barrelHit-%fn')
base.cTrav.addCollider(colNp, handler)
self.accept('barrelHit-' + collSphereName, self.handleEnterBarrel)
nodeToHide = '**/gagMoneyTen'
if barrelIndex % 2:
nodeToHide = '**/gagMoneyFive'
iconToHide = barrel.find(nodeToHide)
if not iconToHide.isEmpty():
iconToHide.hide()
self.barrels.append(barrel)
self.gameBoard = loader.loadModel(
'phase_4/models/minigames/cogthief_game')
self.gameBoard.find('**/floor_TT').hide()
self.gameBoard.find('**/floor_DD').hide()
self.gameBoard.find('**/floor_DG').hide()
self.gameBoard.find('**/floor_MM').hide()
self.gameBoard.find('**/floor_BR').hide()
self.gameBoard.find('**/floor_DL').hide()
zone = self.getSafezoneId()
if zone == ToontownGlobals.ToontownCentral:
self.gameBoard.find('**/floor_TT').show()
elif zone == ToontownGlobals.DonaldsDock:
self.gameBoard.find('**/floor_DD').show()
elif zone == ToontownGlobals.DaisyGardens:
self.gameBoard.find('**/floor_DG').show()
elif zone == ToontownGlobals.MinniesMelodyland:
self.gameBoard.find('**/floor_MM').show()
elif zone == ToontownGlobals.TheBrrrgh:
self.gameBoard.find('**/floor_BR').show()
elif zone == ToontownGlobals.DonaldsDreamland:
self.gameBoard.find('**/floor_DL').show()
else:
self.gameBoard.find('**/floor_TT').show()
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.toonSDs = {}
avId = self.localAvId
toonSD = CogThiefGameToonSD.CogThiefGameToonSD(avId, self)
self.toonSDs[avId] = toonSD
toonSD.load()
self.loadCogs()
self.toonHitTracks = {}
self.toonPieTracks = {}
self.sndOof = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_dirt.ogg')
self.sndRewardTick = base.loadSfx(
'phase_3.5/audio/sfx/tick_counter.ogg')
self.sndPerfect = base.loadSfx('phase_4/audio/sfx/ring_perfect.ogg')
self.timer = ToontownTimer.ToontownTimer()
self.timer.posInTopRightCorner()
self.timer.hide()
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
self.jarImage = purchaseModels.find('**/Jar')
self.jarImage.reparentTo(hidden)
self.rewardPanel = DirectLabel(parent=hidden,
relief=None,
pos=(-0.173, 0.0, -0.55),
scale=0.65,
text='',
text_scale=0.2,
text_fg=(0.95, 0.95, 0, 1),
text_pos=(0, -.13),
text_font=ToontownGlobals.getSignFont(),
image=self.jarImage)
self.rewardPanelTitle = DirectLabel(parent=self.rewardPanel,
relief=None,
pos=(0, 0, 0.06),
scale=0.08,
text=TTLocalizer.CannonGameReward,
text_fg=(0.95, 0.95, 0, 1),
text_shadow=(0, 0, 0, 1))
return
from direct.showbase.DirectObject import DirectObject
from pandac.PandaModules import CollisionHandlerEvent, CollisionHandlerQueue, CollisionHandlerFloor, CollisionHandlerPusher, CollisionNode, CollisionTube, CollisionSphere, CollisionRay, CollisionTraverser, BitMask32
from doomsday.base import Globals, SoundBank
from doomsday.world.Splat import Splat
from panda3d.core import Vec4, Vec3
import math
collHdl = CollisionHandlerEvent()
collHdlF = CollisionHandlerFloor()
collHdlF.setMaxVelocity(8)
collHdlPush = CollisionHandlerPusher()
class WorldCollisions(DirectObject):
def __init__(self):
base.cTrav = CollisionTraverser()
self.called = False
def handleInCollisions(self, entry):
cogCollNames = ['coll_body', 'coll_crit']
intoNode = entry.getIntoNodePath()
fromNode = entry.getFromNodePath()
if (self.called):
return
self.called = True
splatColor = Vec4(0.7, 0.7, 0.8, 1.0)
splatScale = 0.7
if (intoNode.getName() in cogCollNames):
cog = intoNode.getParent().getPythonTag('Cog')
gag = fromNode.getParent().getPythonTag('Stats')
splatColor = gag.getSplatColor()
"""
#=========================================================================
#** Collision system ignition
base.cTrav = CollisionTraverser()
#** This is the known collision handler we use for floor collisions. We'll keep going with the usual settings here as well.
avatarFloorHandler = CollisionHandlerGravity()
avatarFloorHandler.setGravity(9.81 + 25)
avatarFloorHandler.setMaxVelocity(100)
#** the walls collider
wallHandler = CollisionHandlerPusher()
#** we'll use this to 'sense' the fallout impact velocity and also to 'read' various triggers we've put around the map for several purposes.
collisionEvent = CollisionHandlerEvent()
#** Collision masks - this time there is a new one: the TRIGGER_MASK is used to detect certain collision geometry to act as a trigger, therefore we need to distinguish'em from floor and walls.
FLOOR_MASK = BitMask32.bit(1)
WALL_MASK = BitMask32.bit(2)
TRIGGER_MASK = BitMask32.bit(3)
#** Our steering avatar
avatarNP = base.render.attachNewNode(ActorNode('yolkyNP'))
avatarNP.reparentTo(base.render)
# by the way: this time we wont use the same old smiley but a 2d guy for this snippet purposes only - it is just a plane with a texture glued on, a so 2d object then.
avatar = loader.loadModel('yolky')
avatar.reparentTo(avatarNP)
# why this? this is to have our flat puppet rendered always on top of all objects in the scene, either 2d and 3d.
avatar.setDepthWrite(True, 100)
# the rest of the stuff is as usual...
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay
from pandaImports import DirectObject
from tower import *
'''This file handles all the collision events
of our game
'''
#base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav = CollisionTraverser()
#collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
#"In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern('%fn-into-%in')
#"Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern('%fn-again-%in')
#"Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern('%fn-out-%in')
#self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0, 0, 0]
#self.addCollider(mousePicking.pickerNP)
#self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]):
#Let's manage now the collision events:
DO.accept(fromName + "-again-" + intoName, function, extraArgs)
def __init__(self):
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
self.selected = -1
self.selected_node = None
self.selecteds = []
self.multi_select = False
self.multi_selecting = False
self.select_box = NodePath()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.DO = DirectObject()
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-battle', self.col_in_object)
self.DO.accept('mray-out-battle', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
if base.client == False:
self.col_handler.addInPattern("%(player)ft-into-%(player)it")
self.col_handler.addInPattern("%(type)ft-into-%(type)it")
self.DO.accept('army-into-battle', self.col_army_against_battle)
self.DO.accept('army-into-tower', self.col_army_against_tower)
self.DO.accept('1-into-2', self.col_p1_into_p2)
self.pickable = None
self.DO.accept('mouse1', self.mouse_click, ["down"])
self.DO.accept('mouse1-up', self.mouse_click, ["up"])
self.DO.accept('mouse3-up', self.mouse_order)
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.task_select_check, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
self.model = loader.loadModel("models/chest.egg")
self.model.reparentTo(render)
self.model.hide()
cm = CardMaker("blah")
cm.setFrame(-100, 100, -100, 100)
pnode = render.attachNewNode(cm.generate()) #.lookAt(0, 0, -1)
pnode.hide()
def __init__(self):
ShowBase.__init__(self)
global carx, cary, d, cor_ans, count
self.disableMouse()
self.Truck = [0] * 6
self.crate = [0] * 10
self.posc = [0] * 30
self.radX = [0] * 60
self.radY = [0] * 60
self.radZ = [0] * 60
self.sX = [0] * 10
self.sY = [0] * 10
self.sZ = [0] * 10
self.flag = [0] * 10
self.ans = [0] * 10
self.inst1 = addInstructions(0.89, "Correct Answer: " + str(cor_ans))
self.inst2 = addInstructions(0.95, "Time: " + str(time))
self.inst3 = addInstructions(0.84,
"Waste Reamaining " + str(count / 2))
#self.title = addTitle("Recycle Game By : Sandeep Sharma")
p = 0
file = open("ans.txt")
for line in file:
#for p in range(30):
#print line
line = line.split()
self.ans[p] = str(line[0])
p = p + 1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
p = 0
file = open("sample.txt")
for line in file:
#for p in range(30):
line = line[0:len(line) - 1]
#print line
self.posc[p] = int(line)
p = p + 1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
p = 0
file = open("scale.txt")
for line in file:
#for p in range(30):
line = line.split()
#print line
self.sX[p] = float(line[0])
self.sY[p] = float(line[1])
self.sZ[p] = float(line[2])
#print self.radY[p]
p = p + 1
p = 0
file = open("rad.txt")
for line in file:
#for p in range(30):
line = line.split()
#print line
self.radX[p] = float(line[0])
self.radY[p] = float(line[1])
self.radZ[p] = float(line[2])
#print self.radY[p]
p = p + 1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
self.CornField = self.loader.loadModel("cornfield")
self.CornField.reparentTo(self.render)
self.CornField.setScale(1000, 1000, 0)
self.CornField.setPos(0, 0, -8)
self.WM = self.loader.loadModel("WM/Windmill")
self.WM.reparentTo(self.render)
self.WM.setScale(2, 2, 2)
self.WM.setPos(354, 131, 0)
self.WM.setHpr(180, 0, 0)
self.F1 = self.loader.loadModel("Forest/Forest")
self.F1.reparentTo(self.render)
self.F1.setScale(0.8, 0.5, 0.5)
self.F1.setPos(-338, -164, 0)
self.F1.setHpr(90, 0, 0)
self.F2 = self.loader.loadModel("Forest/Forest")
self.F2.reparentTo(self.render)
self.F2.setScale(0.8, 0.5, 0.5)
self.F2.setPos(366, -189, 0)
self.F2.setHpr(90, 0, 0)
self.castle = self.loader.loadModel("castle")
self.castle.reparentTo(self.render)
self.castle.setScale(0.6, 0.8, 0.5)
self.castle.setPos(-97, -200, 0)
self.castle.setHpr(90, 0, 0)
#print self.castle
self.church = self.loader.loadModel("church/Church")
self.church.reparentTo(self.render)
self.church.setScale(2.5, 2.5, 1)
self.church.setPos(90, -200, 0)
self.church.setHpr(180, 0, 0)
self.Temple = self.loader.loadModel("Temple/TempleFort")
self.Temple.reparentTo(self.render)
self.Temple.setScale(0.06, 0.1, 0.18)
self.Temple.setPos(210, -109, 0)
self.house = self.loader.loadModel("BuildingCluster3")
self.house.reparentTo(self.render)
self.house.setScale(1.5, 1.5, 1)
self.house.setPos(208, 86, 0)
self.CityHall = self.loader.loadModel("cityhall/CityHall")
self.CityHall.reparentTo(self.render)
self.CityHall.setScale(1.5, 1.5, 1.5)
self.CityHall.setPos(-188, -84, 0)
self.CityHall.setHpr(90, 0, 0)
self.statue = self.loader.loadModel("statue/statue")
self.statue.reparentTo(self.render)
self.statue.setScale(4.5, 4.5, 3.5)
self.statue.setPos(-191, 105, 0)
self.statue.setHpr(-90, 0, 0)
self.FarmHouse = self.loader.loadModel("farmhouse/FarmHouse")
self.FarmHouse.reparentTo(self.render)
self.FarmHouse.setScale(2.8, 3.5, 2.5)
self.FarmHouse.setPos(-66, 209, 0)
self.Fence1 = self.loader.loadModel("fence/fence")
self.Fence1.reparentTo(self.render)
self.Fence1.setScale(70, 1, 2)
self.Fence1.setPos(0, -418, 0)
self.Fence2 = self.loader.loadModel("fence/fence")
self.Fence2.reparentTo(self.render)
self.Fence2.setScale(70, 1, 2)
self.Fence2.setPos(0, 418, 0)
self.Fence3 = self.loader.loadModel("fence/fence")
self.Fence3.reparentTo(self.render)
self.Fence3.setScale(70, 1, 2)
self.Fence3.setPos(-418, 0, 0)
self.Fence3.setHpr(90, 0, 0)
self.Fence4 = self.loader.loadModel("fence/fence")
self.Fence4.reparentTo(self.render)
self.Fence4.setScale(70, 1, 2)
self.Fence4.setPos(418, 0, 0)
self.Fence4.setHpr(90, 0, 0)
self.CityTerrain = self.loader.loadModel("CityTerrain/CityTerrain")
self.CityTerrain.reparentTo(self.render)
self.CityTerrain.setScale(0.5, 0.5, 0.5)
self.CityTerrain.setPos(0, 0, 0)
self.BeachTerrain = self.loader.loadModel("BeachTerrain/BeachTerrain")
self.BeachTerrain.reparentTo(self.render)
self.BeachTerrain.setScale(0.5, 0.5, 0.5)
self.BeachTerrain.setPos(200, 750, 0)
self.BeachTerrain.setHpr(90, 0, 0)
self.school = self.loader.loadModel("school/school")
self.school.reparentTo(self.render)
self.school.setScale(0.056, 0.07, 0.05)
self.school.setPos(-162, -348, 0)
self.school.setHpr(90, 0, 0)
self.car = Actor("bvw-f2004--jeep/jeep",
{"walk": "bvw-f2004--jeep/jeep-start"})
self.car.setScale(0.5, 0.5, 0.5)
self.car.reparentTo(self.render)
self.car.setPos(carx, cary, -2)
self.car.setHpr(180, 0, 0)
#print self.car
for l in range(10):
self.crate[l] = self.loader.loadModel("model" + str(l + 1) +
"/crate" + str(l + 1) +
".egg")
self.crate[l].setScale(self.sX[l], self.sY[l], self.sZ[l])
self.crate[l].reparentTo(self.render)
self.crate[l].setPos(self.posc[3 * l], self.posc[3 * l + 1], 2)
self.crate[l].setHpr(0, 0, 0)
#self.car.loop("walk")
#self.car.reparentTo(self.render)
#self.car.setScale(2,2,2)
#self.car.setPos(carx,cary,-2)
#self.car.setHpr(0,0,0)
self.museum = self.loader.loadModel("Museum/Museum")
self.museum.reparentTo(self.render)
self.museum.setScale(1, 2, 1.5)
self.museum.setPos(100, 200, 0)
self.museum.setHpr(180, 0, 0)
self.PalmTree = self.loader.loadModel("PalmTree/palmtree")
self.PalmTree.reparentTo(self.render)
self.PalmTree.setScale(2, 2, 3.5)
self.PalmTree.setPos(175, 200, 0)
self.PalmTree.setHpr(0, 0, 0)
self.stadium = self.loader.loadModel("Stadium/stadium")
self.stadium.reparentTo(self.render)
self.stadium.setScale(0.5, 0.5, 0.5)
self.stadium.setPos(13, 0, 0)
self.stadium.setHpr(0, 0, 0)
self.Junkyard = self.loader.loadModel("Junkyard")
self.Junkyard.reparentTo(self.render)
self.Junkyard.setScale(0.2, 0.4, 0.3)
self.Junkyard.setPos(150, -650 / 2 - 25, 0)
self.Junkyard.setHpr(90, 0, 0)
self.BB1 = self.loader.loadModel("BuildingCluster1")
self.BB1.reparentTo(self.render)
self.BB1.setScale(0.5, 0.5, 1)
self.BB1.setPos(-100 - 10, 650 / 2 + 20, 0)
self.BB1.setHpr(270, 0, 0)
self.BB2 = self.loader.loadModel("BB2/BuildingCluster2")
self.BB2.reparentTo(self.render)
self.BB2.setScale(0.5, 0.5, 1)
self.BB2.setPos(-60 - 10, 650 / 2 + 20, 0)
self.BB2.setHpr(270, 0, 0)
self.BB3 = self.loader.loadModel("BB3/BuildingCluster3")
self.BB3.reparentTo(self.render)
self.BB3.setScale(0.5, 0.5, 1)
self.BB3.setPos(-140 - 10, 650 / 2 + 20, 0)
self.BB3.setHpr(270, 0, 0)
self.BB4 = self.loader.loadModel("BB4/BuildingCluster4")
self.BB4.reparentTo(self.render)
self.BB4.setScale(0.5, 0.5, 1)
self.BB4.setPos(-25 - 10, 650 / 2 + 20, 0)
self.BB4.setHpr(270, 0, 0)
self.BB5 = self.loader.loadModel("BB5/BuildingCluster5")
self.BB5.reparentTo(self.render)
self.BB5.setScale(0.5, 0.5, 1)
self.BB5.setPos(-190 - 10, 650 / 2 + 20, 0)
self.BB5.setHpr(270, 0, 0)
self.BS = self.loader.loadModel("BS/blue_sky_sphere")
self.BS.reparentTo(self.render)
self.BS.setScale(1, 1, 1)
self.BS.setPos(-180, 0, 0)
self.flagMain = self.loader.loadModel("Flag/flag")
self.flagMain.setScale(0.3, 0.3, 0.3)
self.flagMain.reparentTo(self.render)
self.flagMain.setPos(carx - 20, cary, 10)
print self.flagMain
for i in range(6):
self.Truck[i] = self.loader.loadModel(
"bvw-f2004--fireengine/fireengine")
self.Truck[i].reparentTo(self.render)
self.Truck[i].setScale(2, 2, 2)
##self.Truck[i].setPos(180,0,0)
#Create the four lerp intervals needed to walk back and forth
self.setTruck()
#self.City = self.loader.loadModel("City/course2")
#self.City.reparentTo(self.render)
#self.City.setScale(2.5,2.5,2.5)
#self.City.setPos(500,0,0)
self.accept('arrow_down', self.moved, [0])
self.accept('arrow_up', self.move, [0])
self.accept("arrow_left", self.change_dc, [0])
self.accept("arrow_right", self.change_da, [0])
self.accept('arrow_down-up', self.moved, [2])
self.accept('arrow_up-up', self.move, [2])
#self.accept("arrow_left-up",self.change_dc,[2])
#self.accept("arrow_right-up",self.change_da,[2])
self.accept('arrow_down-repeat', self.moved, [1])
self.accept('arrow_up-repeat', self.move, [1])
self.accept("arrow_left-repeat", self.change_dc, [1])
self.accept("arrow_right-repeat", self.change_da, [1])
base.cTrav = CollisionTraverser()
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
self.collCount = 0
sColl = self.initCollisionSphere(self.car, 1, 1, 1, True)
base.cTrav.addCollider(sColl[0], self.collHandEvent)
self.accept('into-' + sColl[1], self.collide)
#self.accept('outof-' + sColl[1], self.collide4)
i = 0
for child in render.getChildren():
if child != self.CornField and child != camera and child != self.CityTerrain and child != self.BeachTerrain and child != self.BS and child != self.Fence1 and child != self.Fence2 and child != self.Fence3 and child != self.Fence4:
#print child
tColl = self.initCollisionSphere(child, self.radX[i],
self.radY[i], self.radZ[i],
True)
base.cTrav.addCollider(tColl[0], self.collHandEvent)
#print i
i = i + 1
# Accept the events sent by the collisions.
self.accept('into-' + tColl[1], self.collide)
for l in range(10):
self.flag[l] = self.loader.loadModel("Flag/flag")
self.flag[l].setScale(0.3, 0.3, 0.3)
self.flag[l].reparentTo(self.render)
self.flag[l].setPos(self.posc[3 * l], self.posc[3 * l + 1], 10)
# self.accept( 'into-' + sColl[1], self.collide)
#self.accept('outof-' + tColl[1], self.collide2)
# print carx,cary
# cs = CollisionSphere(0, 0, 0, 10)
# fromObject = self.car.attachNewNode(CollisionNode('cnode'))
# fromObject.node().addSolid(cs)
# fromObject.show()
# pusher = CollisionHandlerPusher()
# pusher.addCollider(fromObject, self.car)
# base.cTrav = CollisionTraverser()
# base.cTrav.addCollider(fromObject, pusher)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
