def load(self):
self.root = NodePath('PartyCog-%d' % self.id)
self.root.reparentTo(self.parentNode)
path = 'phase_13/models/parties/cogPinata_'
self.actor = Actor(
path + 'actor', {
'idle': path + 'idle_anim',
'down': path + 'down_anim',
'up': path + 'up_anim',
'bodyHitBack': path + 'bodyHitBack_anim',
'bodyHitFront': path + 'bodyHitFront_anim',
'headHitBack': path + 'headHitBack_anim',
'headHitFront': path + 'headHitFront_anim'
})
self.actor.setBlend(
frameBlend=config.GetBool('interpolate-animations', True))
self.actor.reparentTo(self.root)
self.temp_transform = Mat4()
self.head_locator = self.actor.attachNewNode('temphead')
self.bodyColl = CollisionTube(0, 0, 1, 0, 0, 5.75, 0.75)
self.bodyColl.setTangible(1)
self.bodyCollNode = CollisionNode('PartyCog-%d-Body-Collision' %
self.id)
self.bodyCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.bodyCollNode.addSolid(self.bodyColl)
self.bodyCollNodePath = self.root.attachNewNode(self.bodyCollNode)
self.headColl = CollisionTube(0, 0, 3, 0, 0, 3.0, 1.5)
self.headColl.setTangible(1)
self.headCollNode = CollisionNode('PartyCog-%d-Head-Collision' %
self.id)
self.headCollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.headCollNode.addSolid(self.headColl)
self.headCollNodePath = self.root.attachNewNode(self.headCollNode)
self.arm1Coll = CollisionSphere(1.65, 0, 3.95, 1.0)
self.arm1Coll.setTangible(1)
self.arm1CollNode = CollisionNode('PartyCog-%d-Arm1-Collision' %
self.id)
self.arm1CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm1CollNode.addSolid(self.arm1Coll)
self.arm1CollNodePath = self.root.attachNewNode(self.arm1CollNode)
self.arm2Coll = CollisionSphere(-1.65, 0, 3.45, 1.0)
self.arm2Coll.setTangible(1)
self.arm2CollNode = CollisionNode('PartyCog-%d-Arm2-Collision' %
self.id)
self.arm2CollNode.setCollideMask(ToontownGlobals.PieBitmask)
self.arm2CollNode.addSolid(self.arm2Coll)
self.arm2CollNodePath = self.root.attachNewNode(self.arm2CollNode)
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound(
'AA_wholepie_only.ogg')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.ogg')
self.hole = loader.loadModel('phase_13/models/parties/cogPinataHole')
self.hole.setTransparency(True)
self.hole.setP(-90.0)
self.hole.setScale(3)
self.hole.setBin('ground', 3)
self.hole.reparentTo(self.parentNode)
def Init_coll(self):
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("MUR")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("MUR")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wall.show()
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("MUR")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wall.show()
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("MUR")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
wall.show()
def collisionInit(self):
self.pusher.addCollider(self.player.collider, self.player.actor)
self.cTrav.addCollider(self.player.collider, self.pusher)
self.pusher.setHorizontal(True)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
def __init__(self, game, id, x, y):
NodePath.__init__(self, 'dropNode%s' % id)
self.game = game
self.id = id
self.reparentTo(hidden)
self.setPos(x, y, 0)
shadow = loader.loadModel('phase_3/models/props/square_drop_shadow')
shadow.setZ(0.2)
shadow.setBin('ground', 10)
shadow.setColor(1, 1, 1, 1)
shadow.reparentTo(self)
self.shadow = shadow
drop = CogdoUtil.loadMazeModel('cabinetSmFalling')
roll = random.randint(-15, 15)
drop.setHpr(0, 0, roll)
drop.setZ(Globals.DropHeight)
self.collTube = CollisionTube(0, 0, 0, 0, 0, 4, Globals.DropCollisionRadius)
self.collTube.setTangible(0)
name = Globals.DropCollisionName
self.collNode = CollisionNode(name)
self.collNode.addSolid(self.collTube)
self.collNodePath = drop.attachNewNode(self.collNode)
self.collNodePath.hide()
self.collNodePath.setTag('isFalling', str('True'))
drop.reparentTo(self)
self.drop = drop
self._dropSfx = base.cogdoGameAudioMgr.createSfxIval('drop', volume=0.6)
def loadFood(self, foodIndex):
self.foodNum += 1
if foodIndex in self.foodModelDict:
foodModel = self.foodModelDict[foodIndex]
foodModel.reparentTo(self.foodNodes[foodIndex])
colNp = foodModel.find('**/FoodCol*')
colNp.setTag('foodNum', str(self.foodNum))
else:
foodModelScale = ToontownGlobals.BossbotFoodModelScale
foodModel = loader.loadModel('phase_12/models/bossbotHQ/canoffood')
foodModel.setScale(foodModelScale)
foodModel.reparentTo(self.foodNodes[foodIndex])
target = CollisionTube(4, 0, 0, -4, 0, 0, 2)
target.setTangible(0)
colName = 'FoodCol-%d-%d' % (self.index, foodIndex)
targetNode = CollisionNode(colName)
targetNode.addSolid(target)
targetNode.setCollideMask(ToontownGlobals.WallBitmask)
targetNodePath = foodModel.attachNewNode(targetNode)
targetNodePath.setScale(1.0 / foodModelScale)
targetNodePath.setTag('foodIndex', str(foodIndex))
targetNodePath.setTag('beltIndex', str(self.index))
targetNodePath.setTag('foodNum', str(self.foodNum))
targetNodePath.setZ(targetNodePath.getZ() - 1.5)
self.accept('enter' + colName, self.touchedFood)
self.foodModelDict[foodIndex] = foodModel
def loadToonup(self, toonupIndex):
self.toonupNum += 1
if toonupIndex in self.toonupModelDict:
toonupModel = self.toonupModelDict[toonupIndex]
toonupModel.reparentTo(self.foodNodes[toonupIndex])
colNp = toonupModel.find('**/ToonupCol*')
colNp.setTag('toonupNum', str(self.toonupNum))
else:
toonupModelScale = self.ToonupScales[toonupIndex]
modelName = self.ToonupModels[toonupIndex]
toonupModel = loader.loadModel(modelName)
self.foodNodes[toonupIndex].setZ(self.beltHeight - 0.1)
toonupModel.setZ(self.ToonupZOffsets[toonupIndex])
toonupModel.setScale(toonupModelScale)
toonupModel.reparentTo(self.foodNodes[toonupIndex])
target = CollisionTube(4, 0, 0, -4, 0, 0, 2)
target.setTangible(0)
colName = 'ToonupCol-%d-%d' % (self.index, toonupIndex)
targetNode = CollisionNode(colName)
targetNode.addSolid(target)
targetNode.setCollideMask(ToontownGlobals.WallBitmask)
targetNodePath = toonupModel.attachNewNode(targetNode)
targetNodePath.setScale(1.0 / toonupModelScale)
targetNodePath.setTag('toonupIndex', str(toonupIndex))
targetNodePath.setTag('beltIndex', str(self.index))
targetNodePath.setTag('toonupNum', str(self.toonupNum))
targetNodePath.setZ(targetNodePath.getZ() - 1.5 / toonupModelScale)
self.accept('enter' + colName, self.touchedToonup)
self.toonupModelDict[toonupIndex] = toonupModel
def createToon(toonId,
x=0,
y=0,
z=0,
h=0,
p=0,
r=0,
parent=render,
anim='neutral',
LOD=1000,
isDisguised=False,
suitType='f',
coll=True):
newToon = NPCToons.createLocalNPC(toonId)
if not newToon:
newToon = NPCToons.createLocalNPC(1)
newToon.head = newToon.find('**/__Actor_head')
if isDisguised:
newToon.putOnSuit(suitType, False, False)
if coll:
collTube = CollisionTube(0, 0, 0.5, 0, 0, 4, 2)
collNode = CollisionNode('suit')
collNode.addSolid(collTube)
newToon.attachNewNode(collNode)
else:
newToon.useLOD(LOD)
if coll:
newToon.initializeBodyCollisions('toon')
newToon.setPosHpr(x, y, z, h, p, r)
newToon.reparentTo(parent)
newToon.loop(anim)
return newToon
def generate(self):
self.cart = loader.loadModel(self.cartModelPath)
self.cart.reparentTo(render)
self.cartBody = self.cart.find('**/main_body')
self.cartBase = self.cart.find('**/cart_base*')
self.cartBody.setColorScale(0.8, 0.1, 0.1, 1)
self.cartBase.setColorScale(0.1, 0.8, 0.1, 1)
self.swag = Suit.Suit()
self.swag.dna = SuitDNA.SuitDNA()
self.swag.dna.newSuit('sf')
self.swag.setDNA(self.swag.dna)
self.swag.setName("Smokin' Claus")
nameInfo = TTLocalizer.SuitBaseNameWithLevel % {'name': "Smokin' Claus", 'dept': TTLocalizer.Sellbot,
'level': 50}
self.swag.setDisplayName(nameInfo)
self.swag.setPickable(False)
self.swag.addActive()
self.collTube = CollisionTube(0, 0, 0.5, 0, 0, 4, 4)
self.collNode = CollisionNode('suit')
self.collNode.addSolid(self.collTube)
self.collNodePath = self.swag.attachNewNode(self.collNode)
self.swag.loop('sit')
self.swag.setScale(0.7)
self.swag.setH(180)
self.swag.setPos(0, -1, -1.5)
self.swag.reparentTo(self.cart.find('**/seat1'))
def createCog(cogType,
x=0,
y=0,
z=0,
h=0,
p=0,
r=0,
isSkelecog=False,
isWaiter=False,
anim='neutral',
parent=render,
name=None,
dept=None,
level=None,
coll=True):
newCog = Suit.Suit()
newCog.dna = SuitDNA.SuitDNA()
newCog.dna.newSuit(cogType)
newCog.setDNA(newCog.dna)
newCog.setPickable(0)
if isWaiter:
newCog.makeWaiter()
if isSkelecog:
newCog.makeSkeleton(True)
newCog.setName(TTLocalizer.Skeleton)
if name != None:
newCog.setName(name)
if dept is False:
nameInfo = TTLocalizer.SuitBaseNameWithoutDept % {
'name': newCog._name,
'level': level if level != None else newCog.getActualLevel()
}
else:
if cogType == 'sj':
nameInfo = 'Shadow Justice'
else:
if cogType == 'ph':
nameInfo = TTLocalizer.SuitBaseNameWithLevel % {
'name': newCog._name,
'dept': 'Crazybot',
'level':
level if level != None else newCog.getActualLevel()
}
else:
nameInfo = TTLocalizer.SuitBaseNameWithLevel % {
'name': newCog._name,
'dept': dept if dept != None else newCog.getStyleDept(),
'level':
level if level != None else newCog.getActualLevel()
}
newCog.reparentTo(parent)
newCog.setPosHpr(x, y, z, h, p, r)
newCog.loop(anim)
newCog.setDisplayName(nameInfo)
if coll:
collTube = CollisionTube(0, 0, 0.5, 0, 0, 4, 2)
collNode = CollisionNode('suit')
collNode.addSolid(collTube)
collNodePath = newCog.attachNewNode(collNode)
return newCog
def initGagCollision(self, name, radius):
self.gagCollisionName = name
collision = CollisionTube(0, 0, 0, 0, 0, 4, radius)
collision.setTangible(1)
self.gagCollNode = CollisionNode(self.gagCollisionName)
self.gagCollNode.setIntoCollideMask(ToontownGlobals.PieBitmask)
self.gagCollNode.addSolid(collision)
self.gagCollNodePath = self.object.attachNewNode(self.gagCollNode)
def initializeBodyCollisions(self):
self.collTube = CollisionTube(0, 0, 0.5, 0, 0,
self.height - self.getRadius(),
self.getRadius())
self.collNode = CollisionNode(self.getCollisionId())
self.collNode.addSolid(self.collTube)
self.collNodePath = self.attachNewNode(self.collNode)
self.collNode.setCollideMask(BitmaskGlobals.WallBitmask)
def createCog(cogType,
x=0,
y=0,
z=0,
h=0,
p=0,
r=0,
isSkelecog=False,
isWaiter=False,
isVirtual=False,
isSkeleRevive=False,
colorType=NametagGroup.CCSuit,
anim='neutral',
parent=render,
name=None,
dept=None,
level=None,
coll=True):
newCog = Suit.Suit()
newCog.dna = SuitDNA.SuitDNA()
newCog.dna.newSuit(cogType)
newCog.setDNA(newCog.dna)
newCog.setPlayerType(colorType)
newCog.setPickable(0)
level = level if level != None else newCog.getActualLevel()
if isWaiter:
newCog.makeWaiter()
if isSkelecog:
newCog.makeSkeleton()
newCog.setName(TTLocalizer.Skeleton)
if isVirtual:
newCog.makeVirtual()
if isSkeleRevive:
level = '%s%s' % (level, TTLocalizer.SkeleRevivePostFix)
if name != None:
newCog.setName(name)
if dept is False:
nameInfo = TTLocalizer.SuitBaseNameWithoutDept % {
'name': newCog._name,
'level': level
}
else:
nameInfo = TTLocalizer.SuitBaseNameWithLevel % {
'name': newCog._name,
'dept': dept if dept != None else newCog.getStyleDept(),
'level': level
}
newCog.setPosHpr(x, y, z, h, p, r)
newCog.reparentTo(parent)
newCog.loop(anim)
newCog.setDisplayName(nameInfo)
if coll:
collTube = CollisionTube(0, 0, 0.5, 0, 0, 4, 2)
collNode = CollisionNode('suit')
collNode.addSolid(collTube)
newCog.attachNewNode(collNode)
return newCog
def loadModels(self):
self.playArea = loader.loadModel('phase_13/models/parties/partyTugOfWar')
self.playArea.reparentTo(self.root)
self.sign.reparentTo(self.playArea.find('**/TugOfWar_sign_locator'))
self.dockPositions = [[], []]
for i in range(4):
self.dockPositions[0].append(Point3(-PartyGlobals.TugOfWarInitialToonPositionsXOffset - PartyGlobals.TugOfWarToonPositionXSeparation * i, 0.0, PartyGlobals.TugOfWarToonPositionZ))
for i in range(4):
self.dockPositions[1].append(Point3(PartyGlobals.TugOfWarInitialToonPositionsXOffset + PartyGlobals.TugOfWarToonPositionXSeparation * i, 0.0, PartyGlobals.TugOfWarToonPositionZ))
self.hopOffPositions = [[], []]
for i in range(1, 5):
self.hopOffPositions[PartyGlobals.TeamActivityTeams.LeftTeam].append(self.playArea.find('**/leftTeamHopOff%d_locator' % i).getPos())
self.hopOffPositions[PartyGlobals.TeamActivityTeams.RightTeam].append(self.playArea.find('**/rightTeamHopOff%d_locator' % i).getPos())
for i in range(1, 5):
pos = self.playArea.find('**/fallenToon%d_locator' % i).getPos()
self.fallenPositions.append(pos)
self.joinCollision = []
self.joinCollisionNodePaths = []
for i in range(len(PartyGlobals.TeamActivityTeams)):
collShape = CollisionTube(PartyGlobals.TugOfWarJoinCollisionEndPoints[0], PartyGlobals.TugOfWarJoinCollisionEndPoints[1], PartyGlobals.TugOfWarJoinCollisionRadius)
collShape.setTangible(True)
self.joinCollision.append(CollisionNode('TugOfWarJoinCollision%d' % i))
self.joinCollision[i].addSolid(collShape)
tubeNp = self.playArea.attachNewNode(self.joinCollision[i])
tubeNp.node().setCollideMask(ToontownGlobals.WallBitmask)
self.joinCollisionNodePaths.append(tubeNp)
self.joinCollisionNodePaths[i].setPos(PartyGlobals.TugOfWarJoinCollisionPositions[i])
self.__enableCollisions()
ropeModel = loader.loadModel('phase_4/models/minigames/tug_of_war_rope')
self.ropeTexture = ropeModel.findTexture('*')
ropeModel.removeNode()
for i in range(PartyGlobals.TugOfWarMaximumPlayersPerTeam * 2 - 1):
rope = Rope(self.uniqueName('TugRope%d' % i))
if rope.showRope:
rope.ropeNode.setRenderMode(RopeNode.RMBillboard)
rope.ropeNode.setThickness(0.2)
rope.setTexture(self.ropeTexture)
rope.ropeNode.setUvMode(RopeNode.UVDistance)
rope.ropeNode.setUvDirection(1)
rope.setTransparency(1)
rope.setColor(0.89, 0.89, 0.6, 1.0)
rope.reparentTo(self.root)
rope.stash()
self.tugRopes.append(rope)
self.splash = Splash.Splash(self.root)
self.splash.setScale(2.0, 4.0, 1.0)
pos = self.fallenPositions[0]
self.splash.setPos(pos[0], pos[1], PartyGlobals.TugOfWarSplashZOffset)
self.splash.hide()
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
else:
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 loadCollision(self):
collTube = CollisionTube(0.0, 0.0, self.z, 0.0, 0.0, self.z, 5.4)
collTube.setTangible(True)
self.trampolineCollision = CollisionNode(self.uniqueName('TrampolineCollision'))
self.trampolineCollision.addSolid(collTube)
self.trampolineCollision.setCollideMask(OTPGlobals.CameraBitmask | OTPGlobals.WallBitmask)
self.trampolineCollisionNP = self.tramp.attachNewNode(self.trampolineCollision)
collSphere = CollisionSphere(0.0, 0.0, self.z, 7.0)
collSphere.setTangible(False)
self.trampolineTrigger = CollisionNode(self.uniqueName('TrampolineTrigger'))
self.trampolineTrigger.addSolid(collSphere)
self.trampolineTrigger.setIntoCollideMask(OTPGlobals.WallBitmask)
self.trampolineTriggerNP = self.tramp.attachNewNode(self.trampolineTrigger)
self.accept('enter%s' % self.uniqueName('TrampolineTrigger'), self.onTrampolineTrigger)
def show_target(self):
self.target_select()
self.intoObject = self.tar.attachNewNode(CollisionNode('colintoNode'))
if self.table[self.trial_counter,7] == "sphere":
self.intoObject.node().addSolid(CollisionSphere(0,0,0,1))
elif self.table[self.trial_counter,7] == "cylinder":
self.intoObject.node().addSolid(CollisionTube(0,0,-2,0,0,2,1))
else:
raise NameError("No such collision type")
self.tar.show()
#hide players not related to target
for i in range(5):
if i not in self.highlighted_indices:
self.players[i].hide()
def 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 createUniqueToon(name,
dna,
hat,
glasses,
backpack,
shoes,
x=0,
y=0,
z=0,
h=0,
p=0,
r=0,
parent=render,
anim='neutral',
LOD=1000,
isDisguised=False,
suitType='f',
suitDept='c',
isWaiter=False,
isRental=False,
coll=True,
colorType=NametagGroup.CCNonPlayer,
cogLevels=(0, 0, 0, 0, 0),
cheesyEffect=ToontownGlobals.CENormal,
nametagStyle=100):
newToon = Toon.Toon()
newToon.setName(name)
newToon.setPickable(0)
newToon.setPlayerType(colorType)
if nametagStyle == 100:
font = loader.loadFont(TTLocalizer.InterfaceFont)
else:
font = loader.loadFont(TTLocalizer.NametagFonts[nametagStyle])
newToon.nametag.setFont(font)
newDNA = ToonDNA.ToonDNA()
newDNA.newToonFromProperties(*dna)
newToon.setDNAString(newDNA.makeNetString())
newToon.applyCheesyEffect(cheesyEffect, 0)
newToon.head = newToon.find('**/__Actor_head')
newToon.setHat(*hat)
newToon.setBackpack(*backpack)
newToon.setGlasses(*glasses)
newToon.setShoes(*shoes)
if isDisguised:
if isWaiter:
cogType = 4
else:
cogType = 0
newToon.cogLevels = []
for l in cogLevels:
newToon.cogLevels.append(l)
if cogType in ToontownGlobals.PutOnSuitRental or isRental:
index = ToontownGlobals.CogDepts.index(suitDept)
newToon.putOnSuit(index, cogType=cogType, rental=True)
else:
newToon.putOnSuit(suitType, cogType=cogType, rental=isRental)
if coll:
collTube = CollisionTube(0, 0, 0.5, 0, 0, 4, 2)
collNode = CollisionNode('suit')
collNode.addSolid(collTube)
newToon.attachNewNode(collNode)
else:
newToon.useLOD(LOD)
if coll:
newToon.initializeBodyCollisions('toon')
newToon.setPosHpr(x, y, z, h, p, r)
newToon.reparentTo(parent)
newToon.loop(anim)
return newToon
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.exitFunc = self.cleanup
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
self.pusher.add_in_pattern("%fn-into-%in")
self.accept("trapEnemy-into-wall", self.stopTrap)
self.accept("trapEnemy-into-trapEnemy", self.stopTrap)
self.accept("trapEnemy-into-player", self.trapHitsSomething)
self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = None
self.enemies = []
self.trapEnemies = []
self.deadEnemies = []
self.spawnPoints = []
numPointsPerWall = 5
for i in range(numPointsPerWall):
coord = 7.0/numPointsPerWall + 0.5
self.spawnPoints.append(Vec3(-7.0, coord, 0))
self.spawnPoints.append(Vec3(7.0, coord, 0))
self.spawnPoints.append(Vec3(coord, -7.0, 0))
self.spawnPoints.append(Vec3(coord, 7.0, 0))
self.initialSpawnInterval = 1.0
self.minimumSpawnInterval = 0.2
self.spawnInterval = self.initialSpawnInterval
self.spawnTimer = self.spawnInterval
self.maxEnemies = 2
self.maximumMaxEnemies = 20
self.numTrapsPerSide = 2
self.difficultyInterval = 5.0
self.difficultyTimer = self.difficultyInterval
self.enemySpawnSound = loader.loadSfx("Sounds/enemySpawn.ogg")
self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7),
fadeScreen = 0.4,
relief = DGG.FLAT,
frameTexture = "UI/stoneFrame.png")
self.gameOverScreen.hide()
self.font = loader.loadFont("Fonts/Wbxkomik.ttf")
buttonImages = (
loader.loadTexture("UI/UIButton.png"),
loader.loadTexture("UI/UIButtonPressed.png"),
loader.loadTexture("UI/UIButtonHighlighted.png"),
loader.loadTexture("UI/UIButtonDisabled.png")
)
label = DirectLabel(text = "Game Over!",
parent = self.gameOverScreen,
scale = 0.1,
pos = (0, 0, 0.2),
text_font = self.font,
relief = None)
self.finalScoreLabel = DirectLabel(text = "",
parent = self.gameOverScreen,
scale = 0.07,
pos = (0, 0, 0),
text_font = self.font,
relief = None)
btn = DirectButton(text = "Restart",
command = self.startGame,
pos = (-0.3, 0, -0.2),
parent = self.gameOverScreen,
scale = 0.07,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text = "Quit",
command = self.quit,
pos = (0.3, 0, -0.2),
parent = self.gameOverScreen,
scale = 0.07,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
self.titleMenuBackdrop = DirectFrame(frameColor = (0, 0, 0, 1),
frameSize = (-1, 1, -1, 1),
parent = render2d)
self.titleMenu = DirectFrame(frameColor = (1, 1, 1, 0))
title = DirectLabel(text = "Panda-chan",
scale = 0.1,
pos = (0, 0, 0.9),
parent = self.titleMenu,
relief = None,
text_font = self.font,
text_fg = (1, 1, 1, 1))
title2 = DirectLabel(text = "and the",
scale = 0.07,
pos = (0, 0, 0.79),
parent = self.titleMenu,
text_font = self.font,
frameColor = (0.5, 0.5, 0.5, 1))
title3 = DirectLabel(text = "Endless Horde",
scale = 0.125,
pos = (0, 0, 0.65),
parent = self.titleMenu,
relief = None,
text_font = self.font,
text_fg = (1, 1, 1, 1))
btn = DirectButton(text = "Start Game",
command = self.startGame,
pos = (0, 0, 0.2),
parent = self.titleMenu,
scale = 0.1,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
btn = DirectButton(text = "Quit",
command = self.quit,
pos = (0, 0, -0.2),
parent = self.titleMenu,
scale = 0.1,
text_font = self.font,
clickSound = loader.loadSfx("Sounds/UIClick.ogg"),
frameTexture = buttonImages,
frameSize = (-4, 4, -1, 1),
text_scale = 0.75,
relief = DGG.FLAT,
text_pos = (0, -0.2))
btn.setTransparency(True)
music = loader.loadMusic("Music/Defending-the-Princess-Haunted.ogg")
music.setLoop(True)
music.setVolume(0.075)
music.play()
def wallColliders(self):
'''
Creates and postions colliders that correspond to the walls of
the game map.
'''
# walls
wallSolid = CollisionTube(-7.0, 39, -2, 7, 39, -2, 1.2)
#wallSolid = CollisionBox(Point3(-5,64,-4), Point3(2.5, 2.5, 0.25))
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
#wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(-2.0, 61, -2, 7, 61, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(-7.0, 30, -2, -7, 61, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(7.0, 40, -2, 7, 61, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(-38, -1, -2, -38, 124, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(38, -1, -2, 38, 124, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(-38, 124, -2, 38, 124, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(-38, -1, -2, 38, -1, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(-38, 101, -2, 0, 101, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(1, 101, -2, 1, 114, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(22.5, 62, -2, 22.5, 93, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
#wall.show()
wallSolid = CollisionTube(8, 92.5, -2, 22.5, 92.5, -2, 1.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
def __init__(self, name='NONAME', id=None):
NetEnt.__init__(self, id)
self.node = NetNodePath(PandaNode('A Character'))
self.node.setTag('ID', str(self.id))
if not id:
self.spawn()
self.node.reparentTo(render)
CharacterPool.add(self)
self.xVelocity = 0
self.yVelocity = 0
self.vertVelocity = None
self.duck = False
self.deltaT = 0
self.sprite = Sprite2d('resources/origsprite.png',
rows=3,
cols=8,
rowPerFace=(0, 1, 2, 1))
self.sprite.createAnim('walk', (1, 0, 2, 0))
self.sprite.createAnim('kick', (5, 6, 7, 6, 5))
self.sprite.node.reparentTo(self.node)
# set up character's name label
self.nameNode = NodePath(TextNode('Char Name'))
self.nameNode.node().setText(name)
self.nameNode.node().setAlign(TextNode.ACenter)
self.nameNode.node().setCardColor(0.2, 0.2, 0.2, 0.5)
self.nameNode.node().setCardAsMargin(0, 0, 0, 0)
self.nameNode.node().setCardDecal(True)
self.nameNode.setZ(1.7)
self.nameNode.setScale(0.2)
self.nameNode.setBillboardAxis()
self.nameNode.reparentTo(self.node)
# collision
self.collisionHandler = CollisionHandlerQueue()
# set up 'from' collision - for detecting char hitting things
self.fromCollider = self.node.attachNewNode(
CollisionNode('fromCollider'))
self.fromCollider.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1))
self.fromCollider.node().setIntoCollideMask(BITMASK_EMPTY)
self.fromCollider.node().setFromCollideMask(BITMASK_TERRAIN)
if SHOW_COLLISIONS:
self.fromCollider.show()
Character.collisionTraverser.addCollider(self.fromCollider,
self.collisionHandler)
# set up 'into' collision - for detecting things hitting char
self.intoCollider = self.node.attachNewNode(
CollisionNode('intoCollider'))
self.intoCollider.node().addSolid(
CollisionTube(0, 0, 0.5, 0, 0, 1, 0.5))
self.intoCollider.node().setIntoCollideMask(BITMASK_CHARACTER)
self.intoCollider.node().setFromCollideMask(BITMASK_EMPTY)
if SHOW_COLLISIONS:
self.intoCollider.show()
self.oldPosition = self.node.getPos()
self.collisionZ = self.node.getZ()
# set up weapons
self.sinceShoot = 10
# speculated client history - used for input prediction
self.posHistory = []
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.tempActor = Actor("Models/PandaChan/act_p3d_chan", {"walk" : "Models/PandaChan/a_p3d_chan_run"})
self.tempActor.getChild(0).setH(180)
self.tempActor.reparentTo(render)
self.tempActor.loop("walk")
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
colliderNode = CollisionNode("player")
colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3))
collider = self.tempActor.attachNewNode(colliderNode)
base.pusher.addCollider(collider, self.tempActor)
base.cTrav.addCollider(collider, self.pusher)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
'L': L0,
'nSegs': numSegs,
'Anoise': posNoise * R0,
'upVector': _UP_
}
Params.update({'rTaper': rTaper, 'R0': R0})
Params.update(cXfactors=[(.05 * R0, 1, 0), (.05 * R0, 2, 0)],
cYfactors=[(.05 * R0, 1, pi / 2), (.05 * R0, 2, pi / 2)])
np = 6
plts = range(np**2) # 6x6 array
ds = 5.0
for it in range(1):
tree = GeneralTree(L0, R0, numSegs, bark, "my tree")
cnp = tree.attachNewNode(CollisionNode('TreeCollisionSolid'))
cnp.node().addSolid(CollisionTube(0, 0, R0, 0, 0, R0 + 3, R0))
# cnp.show()
tree.generate(Params, baseflair=1.45)
tree.reparentTo(base.render)
# DONE GENERATING. WRITE OUT UNSCALED MODEL
print "writing out file"
tree.setScale(1)
tree.setH(180)
tree.setZ(-0.1)
tree.flattenStrong()
tree.writeBamFile('./models/sampleTree' + str(it) + '.bam')
p = random.choice(plts)
tx = ds * (p / np)
def __init__(self):
ShowBase.__init__(self)
#window properties
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.disableMouse()
self.environ = loader.loadModel(
"/c/Users/ryand/Desktop/VSCode_Workspace/Panda3D Practice/Game/Models/environment"
)
self.environ.reparentTo(render)
#place camera high above the ground (z axis)
self.camera.setPos(0, 0, 32)
#set pitch to look down (camera points straight by default)
self.camera.setP(-90)
#ambient light (light for entire scene)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
#use render.setLight to make the light affect the entire scene
render.setLight(self.ambientLightNodePath)
#directional light (shading)
directLight = DirectionalLight("direct light")
self.directLightNodePath = render.attachNewNode(directLight)
self.directLightNodePath.setHpr(-45, -45, 0)
render.setLight(self.directLightNodePath)
#use pandas built in shader generator
render.setShaderAuto()
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.updateTask = taskMgr.add(self.update, "update")
#panda will automatically update the travserser with this cTrav variable
self.cTrav = CollisionTraverser()
#we want to add and remove objects as called for, so add this
self.pusher = CollisionHandlerPusher()
#because its a 2d game
self.pusher.setHorizontal(True)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
#instantiate a player instance and walking enemy instance
self.player = Player()
self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
#starter code for button controls
self.bk_text = "Test Button"
self.textObject = OnscreenText(text=self.bk_text,
pos=(0.95, -0.95),
scale=0.07,
fg=(1, 0.5, 0.5, 1),
align=TextNode.ACenter,
mayChange=1)
self.button = DirectButton(text=("OK", "click!", "rolling over",
"disabled"),
scale=.1,
command=self.setText)
def __init__(self):
ShowBase.__init__(self)
#loader.loadModel("models/environment")
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.disableMouse()
self.environment = loader.loadModel("environment/environment")
self.environment.reparentTo(render)
self.tempActor = Actor("models/act_p3d_chan",
{"walk": "models/a_p3d_chan_run"})
self.tempActor2 = Actor("models/cube.bam")
self.tempActor.reparentTo(render)
self.tempActor2.reparentTo(render)
self.tempActor.setPos(0, 3, 0)
self.tempActor2.setPos(0, 3, 0)
self.tempActor.getChild(0).setH(180)
self.tempActor.loop("walk")
#self.useDrive()
self.useTrackball()
# Move the camera to a position high above the screen
# --that is, offset it along the z-axis.
self.camera.setPos(0, 0, 32)
# Tilt the camera down by setting its pitch.
self.camera.setP(-90)
self.camera.reparentTo(self.tempActor)
self.makeCamera(self.win, displayRegion=(0, 0.5, 0, 1))
self.makeCamera(self.win, displayRegion=(0.5, 1, 0, 1))
self.camList[1].reparentTo(self.tempActor)
self.camList[1].setPos(-0.5, 10, 20)
self.camList[2].setPos(0.5, 0, 0)
self.camList[2].reparentTo(render)
#self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher()
colliderNode = CollisionNode("player")
colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3))
collider = self.tempActor.attachNewNode(colliderNode)
collider.show()
# The pusher wants a collider, and a NodePath that
# should be moved by that collider's collisions.
# In this case, we want our player-Actor to be moved.
base.pusher.addCollider(collider, self.tempActor)
# The traverser wants a collider, and a handler
# that responds to that collider's collisions
base.cTrav.addCollider(collider, self.pusher)
self.pusher.setHorizontal(True)
# Tubes are defined by their start-points, end-points, and radius.
# In this first case, the tube goes from (-8, 0, 0) to (8, 0, 0),
# and has a radius of 0.2.
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
# buffer = self.win.make_texture_buffer("renderBuffer", 1000, 750, to_ram=True)
# data = buffer.get_texture().getRamImage()
# np_buffer = np.frombuffer(data, np.float32)
# print(np_buffer)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
render.setShaderAuto()
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.updateTask = taskMgr.add(self.update, "update")
def makeColl(self, pos, newPos, radius):
"""
make a collision tube for the given stem-parameters
"""
tube = CollisionTube(Point3(pos), Point3(newPos), radius)
self.coll.node().addSolid(tube)
def __init__(self):
ShowBase.__init__(self)
self.player = Player()
self.tempEnemy = WalkingEnemy(Vec3(5, 0, 0))
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
#loader.loadModel("Models/Misc/environment")
self.environment = loader.loadModel("mirroredwalltest.x")
self.environment.reparentTo(render)
self.environment.getChild(0).setPos(0, 50, -4)
self.environment.getChild(0).setH(90)
self.environment.getChild(0).setP(0)
base.disableMouse()
self.camera.setPos(0, 0, 50)
# Tilt the camera down by setting its pitch.
self.camera.setP(-45)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
# In the body of your code
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
render.setShaderAuto()
# walls
wallSolid = CollisionTube(-10.0, 32, -2, 10, 32, -2, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
wallSolid = CollisionTube(-10.0, 51, -2, 10, 51, -2, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
wallSolid = CollisionTube(-8.0, 30, -2, -8, 55, -2, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
wallSolid = CollisionTube(8.0, 30, -2, 8, 55, -2, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
# towers
wallSolid = CollisionTube(-1, 37, -4, -1, 37, 3, 1)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
wallSolid = CollisionTube(-4.5, 48, -4, -4.5, 48, 3, 1)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wall.show()
def __init__(self):
# Initialize the ShowBase class from which we inherit, which will
# create a window and set up everything we need for rendering into it.
ShowBase.__init__(self)
base.setBackgroundColor(0, 0, 0)
self.accept("escape", sys.exit) # Escape quits
self.disableMouse()
camera.setPosHpr(0, 0, 0, 0, 0, 0)
lens = PerspectiveLens()
lens.setFov(90, 60)
lens.setNear(0.01)
lens.setFar(100000)
self.cam.node().setLens(lens)
self.ballSize = 0.025
self.cueLength = 0.2
# self.ballRoot = render.attachNewNode("ballRoot")
# #self.ball = loader.loadModel("models/ball")
# self.ball = loader.loadModel("models/ball_0_center.egg")
# #self.ball = loader.loadModel("models/ball.dae")
# self.ball.setScale(ballSize, ballSize, ballSize)
# self.ball.reparentTo(self.ballRoot)
# #print(self.ball.getBounds())
# #exit(1)
# #self.ballSphere = self.ball.find("**/ball")
# #print(self.ball.getScale()[0])
# cs = CollisionSphere(0, 0, 0, 1)
# self.ballSphere = self.ball.attachNewNode(CollisionNode('ball'))
# self.ballSphere.node().addSolid(cs)
# self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
# self.ballSphere.node().setIntoCollideMask(BitMask32.bit(1))
self.sceneIndex = 0
self.planeInfo = PlaneScene(self.sceneIndex)
self.planeScene = self.planeInfo.generateEggModel()
self.planeScene.setTwoSided(True)
self.planeScene.reparentTo(render)
self.planeScene.hide()
#get geometries from plane predictions
planeTriangles, horizontalPlaneTriangles, self.gravityDirection = self.planeInfo.getPlaneTriangles(
)
# add pool balls
self.ballRoots = []
self.balls = []
self.ballSpheres = []
self.ballGroundRays = []
for ballIndex in xrange(3):
ballRoot = render.attachNewNode("ballRoot_" + str(ballIndex))
ball = loader.loadModel("models/ball_" + str(ballIndex) +
"_center.egg")
ball.setScale(self.ballSize, self.ballSize, self.ballSize)
cs = CollisionSphere(0, 0, 0, 1)
ballSphere = ball.attachNewNode(
CollisionNode('ball_' + str(ballIndex)))
ballSphere.node().addSolid(cs)
ballSphere.node().setFromCollideMask(
BitMask32.bit(0) | BitMask32.bit(1) | BitMask32.bit(3)
| BitMask32.bit(4))
ballSphere.node().setIntoCollideMask(BitMask32.bit(1))
ball.reparentTo(ballRoot)
self.ballRoots.append(ballRoot)
self.balls.append(ball)
self.ballSpheres.append(ballSphere)
ballGroundRay = CollisionRay() # Create the ray
ballGroundRay.setOrigin(0, 0, 0) # Set its origin
ballGroundRay.setDirection(
self.gravityDirection[0], self.gravityDirection[1],
self.gravityDirection[2]) # And its direction
# Collision solids go in CollisionNode
# Create and name the node
ballGroundCol = CollisionNode('ball_ray_' + str(ballIndex))
ballGroundCol.addSolid(ballGroundRay) # Add the ray
ballGroundCol.setFromCollideMask(
BitMask32.bit(2)) # Set its bitmasks
ballGroundCol.setIntoCollideMask(BitMask32.allOff())
# Attach the node to the ballRoot so that the ray is relative to the ball
# (it will always be 10 feet over the ball and point down)
ballGroundColNp = ballRoot.attachNewNode(ballGroundCol)
self.ballGroundRays.append(ballGroundColNp)
ballRoot.hide()
continue
# Finally, we create a CollisionTraverser. CollisionTraversers are what
# do the job of walking the scene graph and calculating collisions.
# For a traverser to actually do collisions, you need to call
# traverser.traverse() on a part of the scene. Fortunately, ShowBase
# has a task that does this for the entire scene once a frame. By
# assigning it to self.cTrav, we designate that this is the one that
# it should call traverse() on each frame.
self.cTrav = CollisionTraverser()
# Collision traversers tell collision handlers about collisions, and then
# the handler decides what to do with the information. We are using a
# CollisionHandlerQueue, which simply creates a list of all of the
# collisions in a given pass. There are more sophisticated handlers like
# one that sends events and another that tries to keep collided objects
# apart, but the results are often better with a simple queue
self.cHandler = CollisionHandlerQueue()
# Now we add the collision nodes that can create a collision to the
# traverser. The traverser will compare these to all others nodes in the
# scene. There is a limit of 32 CollisionNodes per traverser
# We add the collider, and the handler to use as a pair
#self.cTrav.addCollider(self.ballSphere, self.cHandler)
for ballSphere in self.ballSpheres:
self.cTrav.addCollider(ballSphere, self.cHandler)
continue
for ballGroundRay in self.ballGroundRays:
self.cTrav.addCollider(ballGroundRay, self.cHandler)
continue
#self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
# Collision traversers have a built in tool to help visualize collisions.
# Uncomment the next line to see it.
#self.cTrav.showCollisions(render)
# This section deals with lighting for the ball. Only the ball was lit
# because the maze has static lighting pregenerated by the modeler
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor((.55, .55, .55, 1))
directionalLight = DirectionalLight("directionalLight")
directionalLight.setDirection(LVector3(0, 0, -1))
directionalLight.setColor((0.375, 0.375, 0.375, 1))
directionalLight.setSpecularColor((1, 1, 1, 1))
for ballRoot in self.ballRoots:
ballRoot.setLight(render.attachNewNode(ambientLight))
ballRoot.setLight(render.attachNewNode(directionalLight))
continue
# This section deals with adding a specular highlight to the ball to make
# it look shiny. Normally, this is specified in the .egg file.
m = Material()
m.setSpecular((1, 1, 1, 1))
m.setShininess(96)
for ball in self.balls:
ball.setMaterial(m, 1)
continue
# self.original = False
# if self.original:
# camera.setPosHpr(0, 0, 25, 0, -90, 0)
# self.maze = loader.loadModel("models/maze")
# self.maze.reparentTo(render)
# self.walls = self.maze.find("**/wall_collide")
# self.walls.node().setIntoCollideMask(BitMask32.bit(0))
# self.walls.show()
# pass
# create collision entities from plane predictions
self.triNPs = []
for triangleIndex, triangle in enumerate(planeTriangles):
#print(triangleIndex)
#for triangle in triangles:
#print(triangle)
tri = CollisionPolygon(
Point3(triangle[0][0], triangle[0][1], triangle[0][2]),
Point3(triangle[1][0], triangle[1][1], triangle[1][2]),
Point3(triangle[2][0], triangle[2][1], triangle[2][2]))
triNP = render.attachNewNode(
CollisionNode('tri_' + str(triangleIndex)))
triNP.node().setIntoCollideMask(BitMask32.bit(0))
triNP.node().addSolid(tri)
self.triNPs.append(triNP)
#triNP.show()
continue
# create special collision entities for horizontal planes so that balls can fall on one horizontal plane and bounce on it
for triangleIndex, triangle in enumerate(horizontalPlaneTriangles):
#print(triangleIndex)
#for triangle in triangles:
#print(triangle)
tri = CollisionPolygon(
Point3(triangle[0][0], triangle[0][1], triangle[0][2]),
Point3(triangle[1][0], triangle[1][1], triangle[1][2]),
Point3(triangle[2][0], triangle[2][1], triangle[2][2]))
triNP = render.attachNewNode(
CollisionNode('ground_' + str(triangleIndex)))
triNP.node().setIntoCollideMask(BitMask32.bit(2))
triNP.node().addSolid(tri)
self.triNPs.append(triNP)
#triNP.show()
continue
# tri = CollisionPolygon(Point3(-1, 4, -1), Point3(2, 4, -1), Point3(2, 4, 2))
# triNP = render.attachNewNode(CollisionNode('tri'))
# triNP.node().setIntoCollideMask(BitMask32.bit(0))
# triNP.node().addSolid(tri)
# triNP.show()
#self.planeScene.node().setIntoCollideMask(BitMask32.bit(0))
# roomRootNP = self.planeScene
# roomRootNP.flattenLight()
# mesh = BulletTriangleMesh()
# polygons = roomRootNP.findAllMatches("**/+GeomNode")
# # p0 = Point3(-10, 4, -10)
# # p1 = Point3(-10, 4, 10)
# # p2 = Point3(10, 4, 10)
# # p3 = Point3(10, 4, -10)
# # mesh.addTriangle(p0, p1, p2)
# # mesh.addTriangle(p1, p2, p3)
# print(polygons)
# for polygon in polygons:
# geom_node = polygon.node()
# #geom_node.reparentTo(self.render)
# #print(geom_node.getNumGeoms())
# ts = geom_node.getTransform()
# #print(ts)
# for geom in geom_node.getGeoms():
# mesh.addGeom(geom, ts)
# continue
# continue
# #self.scene = roomRootNP
# shape = BulletTriangleMeshShape(mesh, dynamic=False)
# #shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
# room = BulletRigidBodyNode('scene')
# room.addShape(shape)
# #room.setLinearDamping(0.0)
# #room.setFriction(0.0)
# print(shape)
# room.setDeactivationEnabled(False)
# roomNP = render.attachNewNode(room)
# roomNP.setPos(0, 0, 0)
# roomNP.node().setIntoCollideMask(BitMask32.bit(0))
# self.world = BulletWorld()
# self.world.setGravity(Vec3(0, 0, 0))
# self.world.attachRigidBody(roomNP.node())
#room.setRestitution(1)
#self.roomNP = self.scene
# create the cue
self.cueRoot = render.attachNewNode("cueRoot")
self.cue = loader.loadModel("models/cue_center.egg")
self.cue.setScale(self.cueLength * 3, self.cueLength * 3,
self.cueLength)
self.cue.reparentTo(self.cueRoot)
self.cuePos = (10, 0, 0)
self.pickerNode = CollisionNode('mouseRay')
# Attach that node to the camera since the ray will need to be positioned
# relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
# Everything to be picked will use bit 1. This way if we were doing other
# collision we could separate it
self.pickerNode.setFromCollideMask(BitMask32.bit(2))
self.pickerNode.setIntoCollideMask(BitMask32.allOff())
self.pickerRay = CollisionRay() # Make our ray
# Add it to the collision node
self.pickerNode.addSolid(self.pickerRay)
# Register the ray as something that can cause collisions
self.cTrav.addCollider(self.pickerNP, self.cHandler)
self.accept("mouse1", self.hit) # left-click grabs a piece
# create holes
self.holeLength = 0.06
holePos, holeHpr = self.planeInfo.getHolePos()
self.holeRoot = render.attachNewNode("holeRoot")
#self.hole = loader.loadModel("models/hole_horizontal_center.egg")
self.hole = loader.loadModel("models/hole_color.egg")
#self.hole = loader.loadModel("models/billiards_hole_center.egg")
self.hole.setScale(self.holeLength, self.holeLength, self.holeLength)
self.hole.reparentTo(self.holeRoot)
self.hole.setTwoSided(True)
self.holeRoot.setPos(holePos[0], holePos[1], holePos[2])
self.holeRoot.setHpr(holeHpr[0], holeHpr[1], holeHpr[2])
#tex = loader.loadTexture('models/Black_Hole.jpg')
#self.hole.setTexture(tex, 1)
self.holeRoot.hide()
ct = CollisionTube(0, 0, 0, 0, 0.001, 0, 0.5)
self.holeTube = self.hole.attachNewNode(CollisionNode('hole'))
self.holeTube.node().addSolid(ct)
self.holeTube.node().setFromCollideMask(BitMask32.allOff())
self.holeTube.node().setIntoCollideMask(BitMask32.bit(4))
#self.holeTube.show()
# create portals
inPortalPos, inPortalHpr, outPortalPos, outPortalHpr, self.portalNormal = self.planeInfo.getPortalPos(
)
self.portalLength = 0.06
self.inPortalRoot = render.attachNewNode("inPortalRoot")
self.inPortal = loader.loadModel("models/portal_2_center.egg")
self.inPortal.setScale(self.portalLength, self.portalLength,
self.portalLength)
self.inPortal.reparentTo(self.inPortalRoot)
self.inPortalRoot.setPos(inPortalPos[0], inPortalPos[1],
inPortalPos[2])
self.inPortalRoot.setHpr(inPortalHpr[0], inPortalHpr[1],
inPortalHpr[2])
self.inPortalRoot.hide()
ct = CollisionTube(0, 0, 0, 0, 0.001, 0, 1)
self.inPortalTube = self.inPortal.attachNewNode(
CollisionNode('portal_in'))
self.inPortalTube.node().addSolid(ct)
self.inPortalTube.node().setFromCollideMask(BitMask32.allOff())
self.inPortalTube.node().setIntoCollideMask(BitMask32.bit(3))
#self.inPortalTube.hide()
self.outPortalRoot = render.attachNewNode("outPortalRoot")
self.outPortal = loader.loadModel("models/portal_2_center.egg")
self.outPortal.setScale(self.portalLength, self.portalLength,
self.portalLength)
self.outPortal.reparentTo(self.outPortalRoot)
self.outPortalRoot.setPos(outPortalPos[0], outPortalPos[1],
outPortalPos[2])
self.outPortalRoot.setHpr(outPortalHpr[0], outPortalHpr[1],
outPortalHpr[2])
self.outPortalRoot.hide()
ct = CollisionTube(0, 0, 0, 0, 0.001, 0, 1)
self.outPortalTube = self.outPortal.attachNewNode(
CollisionNode('portal_out'))
self.outPortalTube.node().addSolid(ct)
self.outPortalTube.node().setFromCollideMask(BitMask32.allOff())
self.outPortalTube.node().setIntoCollideMask(BitMask32.bit(3))
#self.outPortalTube.hide()
#self.inPortalTube.show()
#self.outPortalTube.show()
#self.holeTube.show()
#self.cTrav.addCollider(self.holeTube, self.cHandler)
# create background image
background_image = loader.loadTexture('dump/' + str(self.sceneIndex) +
'_image.png')
cm = CardMaker('background')
cm.setHas3dUvs(True)
info = np.load('dump/' + str(self.sceneIndex) + '_info.npy')
#self.camera = getCameraFromInfo(self.info)
depth = 10.0
sizeU = info[2] / info[0] * depth
sizeV = info[6] / info[5] * depth
cm.setFrame(Point3(-sizeU, depth, -sizeV),
Point3(sizeU, depth, -sizeV), Point3(sizeU, depth, sizeV),
Point3(-sizeU, depth, sizeV))
self.card = self.render.attachNewNode(cm.generate())
self.card.setTransparency(True)
self.card.setTexture(background_image)
self.card.hide()
self.ballGroundMap = {}
self.ballBouncing = np.full(len(self.balls), 3)
self.started = False
self.start()
#self.hitIndex = -1
self.showing = 'parts'
self.showingProgress = 0
partsScene = PartsScene(self.sceneIndex)
self.planeNPs, self.planeCenters = partsScene.generateEggModel()
return
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
# Turn it around by 45 degrees, and tilt it down by 45 degrees
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.tempActor = Actor("Models/PandaChan/act_p3d_chan", {"walk" : "Models/PandaChan/a_p3d_chan_run"})
self.tempActor.getChild(0).setH(180)
self.tempActor.reparentTo(render)
self.tempActor.setPos(0, 2, 0)
self.tempActor.loop("walk")
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up" : False,
"down" : False,
"left" : False,
"right" : False,
"shoot" : False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.updateTask = taskMgr.add(self.update, "update")
# Panda should now automatically update that traverser!
self.cTrav = CollisionTraverser()
self.pusher = CollisionHandlerPusher() # prevents nominated solid objects from intersecting other solid objects.
colliderNode = CollisionNode("player")
# Add a collision-sphere centred on (0, 0, 0), and with a radius of 0.3
colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.4))
collider = self.tempActor.attachNewNode(colliderNode)
collider.show()
# The pusher wants a collider, and a NodePath that
# should be moved by that collider's collisions.
# In this case, we want our player-Actor to be moved.
base.pusher.addCollider(collider, self.tempActor)
# The traverser wants a collider, and a handler
# that responds to that collider's collisions
base.cTrav.addCollider(collider, self.pusher)
self.pusher.setHorizontal(True)
# Tubes are defined by their start-points, end-points, and radius.
# In this first case, the tube goes from (-8, 0, 0) to (8, 0, 0),
# and has a radius of 0.2.
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
def __init__(self):
ShowBase.__init__(self)
self.disableMouse()
properties = WindowProperties()
properties.setSize(1000, 750)
self.win.requestProperties(properties)
self.exitFunc = self.cleanup
mainLight = DirectionalLight("main light")
self.mainLightNodePath = render.attachNewNode(mainLight)
self.mainLightNodePath.setHpr(45, -45, 0)
render.setLight(self.mainLightNodePath)
ambientLight = AmbientLight("ambient light")
ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1))
self.ambientLightNodePath = render.attachNewNode(ambientLight)
render.setLight(self.ambientLightNodePath)
render.setShaderAuto()
self.environment = loader.loadModel("Models/Misc/environment")
self.environment.reparentTo(render)
self.camera.setPos(0, 0, 32)
self.camera.setP(-90)
self.keyMap = {
"up": False,
"down": False,
"left": False,
"right": False,
"shoot": False
}
self.accept("w", self.updateKeyMap, ["up", True])
self.accept("w-up", self.updateKeyMap, ["up", False])
self.accept("s", self.updateKeyMap, ["down", True])
self.accept("s-up", self.updateKeyMap, ["down", False])
self.accept("a", self.updateKeyMap, ["left", True])
self.accept("a-up", self.updateKeyMap, ["left", False])
self.accept("d", self.updateKeyMap, ["right", True])
self.accept("d-up", self.updateKeyMap, ["right", False])
self.accept("mouse1", self.updateKeyMap, ["shoot", True])
self.accept("mouse1-up", self.updateKeyMap, ["shoot", False])
self.pusher = CollisionHandlerPusher()
self.cTrav = CollisionTraverser()
self.pusher.setHorizontal(True)
self.pusher.add_in_pattern("%fn-into-%in")
self.accept("trapEnemy-into-wall", self.stopTrap)
self.accept("trapEnemy-into-trapEnemy", self.stopTrap)
self.accept("trapEnemy-into-player", self.trapHitsSomething)
self.accept("trapEnemy-into-walkingEnemy", self.trapHitsSomething)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(8.0)
wallSolid = CollisionTube(-8.0, 0, 0, 8.0, 0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setY(-8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(8.0)
wallSolid = CollisionTube(0, -8.0, 0, 0, 8.0, 0, 0.2)
wallNode = CollisionNode("wall")
wallNode.addSolid(wallSolid)
wall = render.attachNewNode(wallNode)
wall.setX(-8.0)
self.updateTask = taskMgr.add(self.update, "update")
self.player = None
self.enemies = []
self.trapEnemies = []
self.deadEnemies = []
self.spawnPoints = []
numPointsPerWall = 5
for i in range(numPointsPerWall):
coord = 7.0 / numPointsPerWall + 0.5
self.spawnPoints.append(Vec3(-7.0, coord, 0))
self.spawnPoints.append(Vec3(7.0, coord, 0))
self.spawnPoints.append(Vec3(coord, -7.0, 0))
self.spawnPoints.append(Vec3(coord, 7.0, 0))
self.initialSpawnInterval = 1.0
self.minimumSpawnInterval = 0.2
self.spawnInterval = self.initialSpawnInterval
self.spawnTimer = self.spawnInterval
self.maxEnemies = 2
self.maximumMaxEnemies = 20
self.numTrapsPerSide = 2
self.difficultyInterval = 5.0
self.difficultyTimer = self.difficultyInterval
self.startGame()