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 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.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.6499999999999999, 0,
3.9500000000000002, 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.6499999999999999, 0,
3.4500000000000002, 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.mp3')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.mp3')
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__(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 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._DistributedPartyTugOfWarActivity__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.20000000000000001)
rope.setTexture(self.ropeTexture)
rope.ropeNode.setUvMode(RopeNode.UVDistance)
rope.ropeNode.setUvDirection(1)
rope.setTransparency(1)
rope.setColor(0.89000000000000001, 0.89000000000000001, 0.59999999999999998, 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 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 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 initCollisions(self):
# Make a sphere, give it a unique name, and parent it
# to the suit.
self.collSphere = CollisionSphere(0, 0, 0, 1.25)
# Make he sphere intangible
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.collNodePath.hide()
# Add a hook looking for collisions with localToon
self.accept('enter' + self.collSphereName, self.handleEnterSphere)
# we need a taller collision tube to collide against for pie
self.pieCollSphere = CollisionTube(0, 0, 0, 0, 0, 4,
self.CollisionRadius)
# Make he sphere intangible
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 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.10000000000000001)
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 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 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 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 xrange(4):
self.dockPositions[0].append(Point3(-PartyGlobals.TugOfWarInitialToonPositionsXOffset - PartyGlobals.TugOfWarToonPositionXSeparation * i, 0.0, PartyGlobals.TugOfWarToonPositionZ))
for i in xrange(4):
self.dockPositions[1].append(Point3(PartyGlobals.TugOfWarInitialToonPositionsXOffset + PartyGlobals.TugOfWarToonPositionXSeparation * i, 0.0, PartyGlobals.TugOfWarToonPositionZ))
self.hopOffPositions = [[], []]
for i in xrange(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 xrange(1, 5):
pos = self.playArea.find('**/fallenToon%d_locator' % i).getPos()
self.fallenPositions.append(pos)
self.joinCollision = []
self.joinCollisionNodePaths = []
for i in xrange(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 xrange(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 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.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 loadCollision(self):
collTube = CollisionTube(0.0, 0.0, 0.0, 0.0, 0.0, 6.0, 5.4)
collTube.setTangible(True)
self.trampolineCollision = CollisionNode(self.uniqueName('TrampolineCollision'))
self.trampolineCollision.addSolid(collTube)
self.trampolineCollision.setCollideMask(OTPGlobals.CameraBitmask | OTPGlobals.WallBitmask)
self.trampolineCollisionNP = self.tramp.attachNewNode(self.trampolineCollision)
collSphere = CollisionSphere(0.0, 0.0, 0.0, 7.0)
collSphere.setTangible(False)
self.trampolineTrigger = CollisionNode(self.uniqueName('TrampolineTrigger'))
self.trampolineTrigger.addSolid(collSphere)
self.trampolineTrigger.setIntoCollideMask(OTPGlobals.WallBitmask)
self.trampolineTriggerNP = self.tramp.attachNewNode(self.trampolineTrigger)
self.accept('enter%s' % self.uniqueName('TrampolineTrigger'), self.onTrampolineTrigger)
def loadCollision(self):
collTube = CollisionTube(0.0, 0.0, 0.0, 0.0, 0.0, 6.0, 5.4)
collTube.setTangible(True)
self.trampolineCollision = CollisionNode(self.uniqueName('TrampolineCollision'))
self.trampolineCollision.addSolid(collTube)
self.trampolineCollision.setCollideMask(OTPGlobals.CameraBitmask | OTPGlobals.WallBitmask)
self.trampolineCollisionNP = self.tramp.attachNewNode(self.trampolineCollision)
collSphere = CollisionSphere(0.0, 0.0, 0.0, 7.0)
collSphere.setTangible(False)
self.trampolineTrigger = CollisionNode(self.uniqueName('TrampolineTrigger'))
self.trampolineTrigger.addSolid(collSphere)
self.trampolineTrigger.setIntoCollideMask(OTPGlobals.WallBitmask)
self.trampolineTriggerNP = self.tramp.attachNewNode(self.trampolineTrigger)
self.accept('enter%s' % self.uniqueName('TrampolineTrigger'), self.onTrampolineTrigger)
def __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 create_stanchions(self):
from pandac.PandaModules import GeomVertexReader, CollisionNode, CollisionTube
self.stanchions = self.stage.findAllMatches('**/=Stanchion')
for stanchion in self.stanchions:
geomnode = stanchion.node()
radius = float(stanchion.getTag('Stanchion'))
geom = geomnode.getGeom(0)
vdata = geom.getVertexData()
for gp in range(geom.getNumPrimitives()):
vreader = GeomVertexReader(vdata, 'vertex')
prim = geom.getPrimitive(gp)
prim = prim.decompose()
for p in range(prim.getNumPrimitives()):
start = prim.getPrimitiveStart(p)
end = prim.getPrimitiveEnd(p)
vertices = []
for v in range(start, end):
vi = prim.getVertex(v)
vreader.setRow(vi)
vertex = vreader.getData3f()
vertices.append(vertex)
vertices.append(vertices[0])
for i in range(1, len(vertices)):
a, b = vertices[i - 1], vertices[i]
stanchion_np = stanchion.attachNewNode(
CollisionNode('stanchion'))
print 'creating cyl with radius %f from %s to %s' % (
radius, a, b)
stanchion_np.node().addSolid(
CollisionTube(a[0], a[1], a[2], b[0], b[1], b[2],
radius))
stanchion_np.node().setFromCollideMask(OBSTACLE_MASK)
geomnode.removeAllGeoms()
def addToonCollision(self):
toon = render.find('**/Toon')
collTube = toon.attachNewNode(CollisionNode('coll_toon'))
collTube.node().addSolid(CollisionTube(0, 0, 0.5, 0, 0, 8, 2))
collTube.node().setIntoCollideMask(Globals.DropBitmask
| Globals.ProjBitmask)
collTube.node().setFromCollideMask(BitMask32.allOff())
base.cTrav.addCollider(collTube, collHdl)
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 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.3500000000000001, 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.7000000000000002, 0.0, 0.0,
2.7000000000000002, 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 None
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.29999999999999999, 0, 0.10000000000000001)
lookAtUp = Vec3(0, -1, 0)
self.stickHinge.lookAt(host.rightHand, lookAtPoint, lookAtUp)
host.play('walk')
host.update()
def createDoor(self):
# Tell DNANode to create the dummy node now
self.createDummy()
# Set the collision geometry; we need first a CollisionNode
sensor = self.node.attachNewNode(CollisionNode(self.name))
# We add that to our CollisionSphere geometry primitive
sensor.node().addSolid(CollisionTube(-14, 0, 0, 14, 0, 0, 1.5))
sensor.node().setFromCollideMask(BitMask32.allOff())
sensor.node().setIntoCollideMask(DOOR_MASK)
sensor.show()
# Collision logic
self.DNAParser.main.accept('playersensor-into-' + self.name,
self.DNAParser.main.transition,
[self.nextroom, self.exit])
def addCogCollision(self, cog):
ent = cog.getCog()
head = cog.getHead()
if (head != None):
sphPos = cog.getHead().getZ(render) + 0.5
else:
sphPos = ent.find('**/joint_head').getPos(render).getZ() + 0.8
collTube = ent.attachNewNode(CollisionNode('coll_body'))
collTube.node().addSolid(
CollisionTube(0, 0, 0.5, 0, 0,
cog.getHeight() - 2, 2))
collTube.node().setIntoCollideMask(Globals.GagBitmask)
collTube.node().setFromCollideMask(BitMask32.allOff())
collSph = ent.attachNewNode(CollisionNode('coll_crit'))
collSph.node().addSolid(CollisionSphere(0, 0, sphPos, 2))
collSph.node().setIntoCollideMask(Globals.GagBitmask)
base.cTrav.addCollider(collTube, collHdl)
base.cTrav.addCollider(collSph, collHdl)
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 loadModel(self):
self.hill = loader.loadModel('phase_12/models/bossbotHQ/mole_hole')
self.hill.setZ(0.0)
self.hill.reparentTo(self)
self.hillColName = 'moleHillCol-%d-%d' % (self.moleField.doId, self.index)
self.moleField.accept('enter' + self.hillColName, self.moleField.handleEnterHill)
self.mole = self.attachNewNode('mole')
self.mole.reparentTo(self)
self.mole.setScale(0.75)
self.mole.setZ(-2.5)
self.moleHead = loader.loadModel('phase_12/models/bossbotHQ/mole_norm')
self.moleHead.reparentTo(self.mole)
moleColName = 'moleCol-%d-%s' % (self.moleField.doId, self.index)
moleSphere = CollisionTube(0, 0, 0, 0, 0, 1, 1)
collNode = CollisionNode(moleColName)
collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
collNode.addSolid(moleSphere)
self.moleColNodePath = self.mole.attachNewNode(collNode)
self.moleColNodePath.stash()
self.moleColNodePath.setScale(1.0)
self.moleField.accept('enter' + moleColName, self.moleField.handleEnterMole)
def __init__(self, game_data, gfx_manager):
self.game_data = game_data
self.gui_traverser = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.selectable_objects = {}
for cid, model in gfx_manager.character_models.items():
new_collision_node = CollisionNode('person_' + str(cid))
new_collision_node.addSolid(
CollisionTube(0, 0, 0.5, 0, 0, 1.5, 0.5))
new_collision_nodepath = model.attachNewNode(new_collision_node)
new_collision_nodepath.setTag("type", "character")
new_collision_nodepath.setTag("id", str(cid))
picker_node = CollisionNode('mouseRay')
picker_np = camera.attachNewNode(picker_node)
self.picker_ray = CollisionRay()
picker_node.addSolid(self.picker_ray)
self.gui_traverser.addCollider(picker_np, self.handler)
self.floor = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
self.floor_np = render.attachNewNode(CollisionNode('floor'))
self.floor_np.setTag("type", "ground")
self.floor_np.node().addSolid(self.floor)
class CogdoMazeDrop(NodePath, DirectObject):
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 disableCollisionDamage(self):
self.collTube.setTangible(1)
self.collTube.setRadius(Globals.DroppedCollisionRadius)
self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.collNodePath.setTag('isFalling', str('False'))
def getDropIval(self):
shadow = self.shadow
drop = self.drop
id = self.id
hangTime = Globals.ShadowTime
dropTime = Globals.DropTime
dropHeight = Globals.DropHeight
targetShadowScale = 0.5
targetShadowAlpha = 0.4
shadowScaleIval = LerpScaleInterval(shadow,
dropTime,
targetShadowScale,
startScale=0)
shadowAlphaIval = LerpColorScaleInterval(
shadow,
hangTime,
Point4(1, 1, 1, targetShadowAlpha),
startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
startPos = Point3(0, 0, dropHeight)
drop.setPos(startPos)
dropIval = LerpPosInterval(drop,
dropTime,
Point3(0, 0, 0),
startPos=startPos,
blendType='easeIn')
dropSoundIval = self._dropSfx
dropSoundIval.node = self
self.drop.setTransparency(1)
def _setRandScale(t):
self.drop.setScale(self, 1 - random.random() / 16,
1 - random.random() / 16,
1 - random.random() / 4)
scaleChange = 0.4 + random.random() / 4
dropShakeSeq = Sequence(
LerpScaleInterval(self.drop,
0.25,
Vec3(1.0 + scaleChange, 1.0 + scaleChange / 2,
1.0 - scaleChange),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.25,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
Func(self.disableCollisionDamage),
LerpScaleInterval(self.drop,
0.2,
Vec3(1.0 + scaleChange / 8,
1.0 + scaleChange / 8,
1.0 - scaleChange / 8),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.2,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.15,
Vec3(1.0 + scaleChange / 16,
1.0 + scaleChange / 16,
1.0 - scaleChange / 16),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.15,
Vec3(1.0, 1.0, 1.0),
blendType='easeInOut'),
LerpScaleInterval(self.drop,
0.1,
Vec3(1.0 + scaleChange / 16,
1.0 + scaleChange / 8,
1.0 - scaleChange / 16),
blendType='easeInOut'),
LerpColorScaleInterval(self.drop, Globals.DropFadeTime,
Vec4(1.0, 1.0, 1.0, 0.0)))
ival = Sequence(Func(self.reparentTo, render),
Parallel(Sequence(WaitInterval(hangTime), dropIval),
shadowIval),
Parallel(Func(self.game.dropHit, self, id),
dropSoundIval, dropShakeSeq),
Func(self.game.cleanupDrop, id),
name='drop%s' % id)
self.ival = ival
return ival
def destroy(self):
self.ival.pause()
self.ival = None
self._dropSfx.pause()
self._dropSfx = None
self.collTube = None
self.collNode = None
self.collNodePath.removeNode()
self.collNodePath = None
self.removeNode()
return
class CogThief(DirectObject):
"""This represents a single cog thief in the cog thief game"""
notify = directNotify.newCategory("CogThief")
DefaultSpeedWalkAnim = 4.
CollisionRadius = 1.25
MaxFriendsVisible = 4
Infinity = 100000.0 # just a really big number
SeparationDistance = 6.0
MinUrgency = 0.5
MaxUrgency = 0.75
def __init__(self, cogIndex, suitType, game, cogSpeed):
self.cogIndex = cogIndex
self.suitType = suitType
self.game = game
self.cogSpeed = cogSpeed
suit = Suit.Suit()
d = SuitDNA.SuitDNA()
d.newSuit(suitType)
suit.setDNA(d)
# cache the walk anim
suit.pose('walk', 0)
self.suit = suit
self.goal = CTGG.NoGoal
self.goalId = CTGG.InvalidGoalId
self.lastLocalTimeStampFromAI = 0
self.lastPosFromAI = Point3(0, 0, 0)
self.lastThinkTime = 0
self.doneAdjust = False
self.barrel = CTGG.NoBarrelCarried
self.signalledAtReturnPos = False
self.defaultPlayRate = 1.0
self.netTimeSentToStartByHit = 0
# steering loosely based on boid code game programming gems #1
# "Portions Copyright (C) Steven Woodcock, 2000"
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
self.bodyLength = self.CollisionRadius * 2
# Desired distance from closest neighbor when flying.
self.cruiseDistance = 2 * self.bodyLength
self.maxVelocity = self.cogSpeed
# Maximum magnitude of acceleration as a fraction of maxSpeed.
self.maxAcceleration = 5.0
self.perceptionRange = 6
self.notify.debug('cogSpeed=%s' % self.cogSpeed)
self.kaboomSound = loader.loadSfx(
"phase_4/audio/sfx/MG_cannon_fire_alt.mp3")
self.kaboom = loader.loadModel(
'phase_4/models/minigames/ice_game_kaboom')
self.kaboom.setScale(2.0)
self.kaboom.setBillboardPointEye()
self.kaboom.hide()
self.kaboomTrack = None
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound(
'AA_wholepie_only.mp3')
def destroy(self):
self.ignoreAll()
self.suit.delete()
self.game = None
def uniqueName(self, baseStr):
return baseStr + '-' + str(self.game.doId)
def handleEnterSphere(self, collEntry):
"""Handle the suit colliding with localToon."""
#assert self.notify.debugStateCall(self)
intoNp = collEntry.getIntoNodePath()
self.notify.debug('handleEnterSphere suit %d hit %s' %
(self.cogIndex, intoNp))
if self.game:
self.game.handleEnterSphere(collEntry)
def gameStart(self, gameStartTime):
self.gameStartTime = gameStartTime
self.initCollisions()
self.startWalkAnim()
def gameEnd(self):
self.moveIval.pause()
del self.moveIval
self.shutdownCollisions()
# keep the suits from walking in place
self.suit.loop('neutral')
def initCollisions(self):
# Make a sphere, give it a unique name, and parent it
# to the suit.
self.collSphere = CollisionSphere(0, 0, 0, 1.25)
# Make he sphere intangible
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.collNodePath.hide()
# Add a hook looking for collisions with localToon
self.accept('enter' + self.collSphereName, self.handleEnterSphere)
# we need a taller collision tube to collide against for pie
self.pieCollSphere = CollisionTube(0, 0, 0, 0, 0, 4,
self.CollisionRadius)
# Make he sphere intangible
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)
#self.pieCollNodePath.show()
# Add a hook looking for collisions with localToon
#self.accept('enter' + self.pieCollSphereName,
# self.handleEnter)
def shutdownCollisions(self):
self.ignore(self.uniqueName('enter' + self.collSphereName))
del self.collSphere
self.collNodePath.removeNode()
del self.collNodePath
del self.collNode
def updateGoal(self, timestamp, inResponseClientStamp, goalType, goalId,
pos):
"""Update our goal and position."""
assert self.notify.debugStateCall(self)
self.notify.debug('self.netTimeSentToStartByHit =%s' %
self.netTimeSentToStartByHit)
if not self.game:
self.notify.debug('updateGoal self.game is None, just returning')
return
if not self.suit:
self.notify.debug('updateGoal self.suit is None, just returning')
return
if self.goal == CTGG.NoGoal:
self.startWalkAnim()
if goalType == CTGG.NoGoal:
self.notify.debug('updateGoal setting position to %s' % pos)
self.suit.setPos(pos)
self.lastThinkTime = 0
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
if goalType == CTGG.RunAwayGoal:
#import pdb; pdb.set_trace()
pass
if inResponseClientStamp < self.netTimeSentToStartByHit and \
self.goal == CTGG.NoGoal and \
goalType == CTGG.RunAwayGoal:
#import pdb; pdb.set_trace()
self.notify.warning(
'ignoring newGoal %s as cog %d was recently hit responsetime=%s hitTime=%s'
% (CTGG.GoalStr[goalType], self.cogIndex,
inResponseClientStamp, self.netTimeSentToStartByHit))
else:
self.lastLocalTimeStampFromAI = globalClockDelta.networkToLocalTime(
timestamp, bits=32)
self.goal = goalType
self.goalId = goalId
self.lastPosFromAI = pos
self.doneAdjust = False
self.signalledAtReturnPos = False
# TODO move the suit to where we expect him to be given the time difference
def startWalkAnim(self):
if self.suit:
self.suit.loop('walk')
speed = self.cogSpeed # float(MazeData.CELL_WIDTH) / self.cellWalkDuration
self.defaultPlayRate = float(self.cogSpeed /
self.DefaultSpeedWalkAnim)
self.suit.setPlayRate(self.defaultPlayRate, 'walk')
def think(self):
"""Calculate where we should go."""
if self.goal == CTGG.ToonGoal:
self.thinkAboutCatchingToon()
elif self.goal == CTGG.BarrelGoal:
self.thinkAboutGettingBarrel()
elif self.goal == CTGG.RunAwayGoal:
self.thinkAboutRunAway()
def thinkAboutCatchingToon(self):
if not self.game:
return
av = self.game.getAvatar(self.goalId)
if av:
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
avPos = av.getPos()
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.notify.debug(
'thinkAboutCatchingToon not doneAdjust setting pos %s' %
myPos)
self.doneAdjust = True
self.suit.setPos(myPos)
if self.game.isToonPlayingHitTrack(self.goalId):
# do nothing, just look at toon
self.suit.headsUp(av)
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
else:
self.commonMove()
newPos = self.suit.getPos()
self.adjustPlayRate(newPos, myPos, diffTime)
self.lastThinkTime = globalClock.getFrameTime()
def convertNetworkStampToGameTime(self, timestamp):
"""Convert a network timestamp to game time."""
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
gameTime = self.game.local2GameTime(localStamp)
return gameTime
def respondToToonHit(self, timestamp):
"""The toon hit us, react appropriately."""
assert self.notify.debugStateCall(self)
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
# using 1.0 sec as fudge
#if localStamp > self.lastLocalTimeStampFromAI:
if self.netTimeSentToStartByHit < timestamp:
self.clearGoal()
self.showKaboom()
# move him to his starting postion
startPos = CTGG.CogStartingPositions[self.cogIndex]
oldPos = self.suit.getPos()
self.suit.setPos(startPos)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug(
'localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToToonHit'
% (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug(
'respondToToonHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def clearGoal(self):
"""Clear goal and goal id."""
self.goal = CTGG.NoGoal
self.goalId = CTGG.InvalidGoalId
def thinkAboutGettingBarrel(self):
"""Go for a barrel."""
if not self.game:
return
if not hasattr(self.game, 'barrels'):
return
if not self.goalId in xrange(len(self.game.barrels)):
return
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
barrel = self.game.barrels[self.goalId]
barrelPos = barrel.getPos()
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.notify.debug(
'thinkAboutGettingBarrel not doneAdjust setting position to %s'
% myPos)
self.suit.setPos(myPos)
"""
diffTime = globalClock.getFrameTime()- self.lastLocalTimeStampFromAI
self.notify.debug('doing adjust, diffTime = %s' % diffTime)
if diffTime < 0:
# it just looks really weird when it moves backwards
diffTime = 0
self.notify.debug('forcing diffTime to %s' % diffTime)
"""
self.doneAdjust = True
displacement = barrelPos - myPos
distanceToToon = displacement.length()
#self.notify.debug('diffTime = %s' % diffTime)
self.suit.headsUp(barrel)
lengthTravelled = diffTime * self.cogSpeed
#self.notify.debug('lengthTravelled = %s' % lengthTravelled)
# don't overshoot our target
if lengthTravelled > distanceToToon:
lengthTravelled = distanceToToon
#self.notify.debug('overshooting lengthTravelled = %s' % lengthTravelled)
displacement.normalize()
dirVector = displacement
dirVector *= lengthTravelled
newPos = myPos + dirVector
# always keep them grounded
newPos.setZ(0)
self.suit.setPos(newPos)
self.adjustPlayRate(newPos, myPos, diffTime)
self.lastThinkTime = globalClock.getFrameTime()
def stopWalking(self, timestamp):
"""Stop the cog from walking."""
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
if localStamp > self.lastLocalTimeStampFromAI:
self.suit.loop('neutral')
self.clearGoal()
def thinkAboutRunAway(self):
"""Go for a barrel."""
if not self.game:
return
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
returnPos = CTGG.CogReturnPositions[self.goalId]
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.suit.setPos(myPos)
"""
diffTime = globalClock.getFrameTime()- self.lastLocalTimeStampFromAI
self.notify.debug('run away doing adjust, diffTime = %s' % diffTime)
if diffTime < 0:
# it just looks really weird when it moves backwards
diffTime = 0
self.notify.debug('forcing diffTime to %s' % diffTime)
"""
self.doneAdjust = True
displacement = returnPos - myPos
distanceToToon = displacement.length()
#self.notify.debug('diffTime = %s' % diffTime)
tempNp = render.attachNewNode('tempRet')
tempNp.setPos(returnPos)
self.suit.headsUp(tempNp)
tempNp.removeNode()
lengthTravelled = diffTime * self.cogSpeed
#self.notify.debug('lengthTravelled = %s' % lengthTravelled)
# don't overshoot our target
if lengthTravelled > distanceToToon:
lengthTravelled = distanceToToon
#self.notify.debug('overshooting lengthTravelled = %s' % lengthTravelled)
displacement.normalize()
dirVector = displacement
dirVector *= lengthTravelled
newPos = myPos + dirVector
# always keep them grounded
newPos.setZ(0)
self.suit.setPos(newPos)
self.adjustPlayRate(newPos, myPos, diffTime)
if (self.suit.getPos() - returnPos).length() < 0.0001:
if not self.signalledAtReturnPos and self.barrel >= 0:
# tell the AI we're at return Pos
self.game.sendCogAtReturnPos(self.cogIndex, self.barrel)
self.signalledAtReturnPos = True
self.lastThinkTime = globalClock.getFrameTime()
def makeCogCarryBarrel(self, timestamp, inResponseClientStamp, barrelModel,
barrelIndex, cogPos):
"""Handle the AI telling us the barrel is attached to a cog."""
#assert self.notify.debugStateCall(self)
if not self.game:
return
localTimeStamp = globalClockDelta.networkToLocalTime(timestamp,
bits=32)
# TODO validate time?
self.lastLocalTimeStampFromAI = localTimeStamp
inResponseGameTime = self.convertNetworkStampToGameTime(
inResponseClientStamp)
self.notify.debug('inResponseGameTime =%s timeSentToStart=%s' %
(inResponseGameTime, self.netTimeSentToStartByHit))
if inResponseClientStamp < self.netTimeSentToStartByHit and \
self.goal == CTGG.NoGoal:
self.notify.warning('ignoring makeCogCarrybarrel')
else:
barrelModel.setPos(0, -1.0, 1.5)
barrelModel.reparentTo(self.suit)
self.suit.setPos(cogPos)
self.barrel = barrelIndex
def makeCogDropBarrel(self, timestamp, inResponseClientStamp, barrelModel,
barrelIndex, barrelPos):
"""Handle the AI telling us the barrel is attached to a cog."""
#assert self.notify.debugStateCall(self)
localTimeStamp = globalClockDelta.networkToLocalTime(timestamp,
bits=32)
# TODO validate time?
self.lastLocalTimeStampFromAI = localTimeStamp
barrelModel.reparentTo(render)
barrelModel.setPos(barrelPos)
self.barrel = CTGG.NoBarrelCarried
#
#self.suit.setPos(cogPos)
def respondToPieHit(self, timestamp):
"""The toon hit us, react appropriately."""
assert self.notify.debugStateCall(self)
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
# argh using 1.0 sec as fudge
#if localStamp > self.lastLocalTimeStampFromAI:
if self.netTimeSentToStartByHit < timestamp:
self.clearGoal()
self.showSplat()
# move him to his starting postion
startPos = CTGG.CogStartingPositions[self.cogIndex]
oldPos = self.suit.getPos()
self.suit.setPos(startPos)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug(
'localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToPieHit'
% (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug(
'respondToPieHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def cleanup(self):
"""Do whatever is necessary to cleanup properly."""
self.clearGoal()
self.ignoreAll()
self.suit.delete()
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.suit = None
self.game = None
def adjustPlayRate(self, newPos, oldPos, diffTime):
"""Adjust animation rate based on how far he's moved."""
# lets slowdown playrate if they're not moving much
lengthTravelled = (newPos - oldPos).length()
if diffTime:
speed = lengthTravelled / diffTime
else:
speed = self.cogSpeed
rateMult = speed / self.cogSpeed
newRate = rateMult * self.defaultPlayRate
self.suit.setPlayRate(newRate, 'walk')
def commonMove(self):
"""Move the cog thief. Common for all 3 behaviors """
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
dt = globalClock.getFrameTime() - self.lastThinkTime
# Step 1: Update our position.
# Update our position based on the velocity
# vector we computed last time around.
self.oldpos = self.suit.getPos()
# save off our previous position
pos = self.suit.getPos()
pos += self.velocity * dt
# apply velocities.
self.suit.setPos(pos)
# Step 2: SeeFriends.
# Determine if we can see any of our flockmates.
self.seeFriends()
acc = Vec3(0, 0, 0)
# well first off we want to move to our target
self.accumulate(acc, self.getTargetVector())
# Step 3: Flocking behavior.
# Do we see any of our flockmates? If yes, it's time to implement
# the first Three Rules (they don't matter if we can't see anybody)
if self.numFlockmatesSeen > 0:
#if hasattr(base,'doDebug') and base.doDebug:
# import pdb; pdb.set_trace()
keepDistanceVector = self.keepDistance()
oldAcc = Vec3(acc)
self.accumulate(acc, keepDistanceVector)
if self.cogIndex == 0:
#self.notify.debug('oldAcc=%s, keepDist=%s newAcc=%s' %
# (oldAcc,keepDistanceVector, acc))
pass
# Step 8: Constrain acceleration
# If our acceleration change is more than we allow, constrain it
if (acc.length() > self.maxAcceleration):
# definitely too much...constrain to maximum change
acc.normalize()
acc *= self.maxAcceleration
# Step 9: Implementation.
# Here's where we apply our newly computed acceleration vector
# to create a new velocity vector to use next update cycle.
self.oldVelocity = self.velocity
# save off our previous velocity
# now add in the acceleration
self.velocity += acc
# Step 10: constraint Y velocity changes.
# Attempt to restrict flight straight up/down by damping out Y axis velocity.
# This isn't strictly necessary, but does lead to more realistic looking flight.
# Step 11: Constrain our speed.
# If we're moving faster than we're allowed to move, constrain our velocity.
if self.velocity.length() > self.maxVelocity:
self.velocity.normalize()
self.velocity *= self.maxVelocity
# Step 12: Compute roll/pitch/yaw.
# Compute our orientation after all this speed adjustment nonsense.
# bah no need, we turn on a dime towards our velocity
forwardVec = Vec3(1, 0, 0)
heading = rad2Deg(math.atan2(self.velocity[1], self.velocity[0]))
heading -= 90
self.suit.setH(heading)
def getTargetVector(self):
"""Return a vector to my goal."""
targetPos = Point3(0, 0, 0)
if self.goal == CTGG.ToonGoal:
av = self.game.getAvatar(self.goalId)
if av:
targetPos = av.getPos()
elif self.goal == CTGG.BarrelGoal:
barrel = self.game.barrels[self.goalId]
targetPos = barrel.getPos()
elif self.goal == CTGG.RunAwayGoal:
targetPos = CTGG.CogReturnPositions[self.goalId]
targetPos.setZ(0)
myPos = self.suit.getPos()
diff = targetPos - myPos
if diff.length() > 1.0:
diff.normalize()
diff *= 1.0
return diff
def accumulate(self, accumulator, valueToAdd):
"""Return the magnitude of the accumulated vector."""
accumulator += valueToAdd
return accumulator.length()
def seeFriends(self):
"""Determines which flockmates a given flock boid can see."""
# clear the existing visibility list of any holdover from last round
self.clearVisibleList()
for cogIndex in self.game.cogInfo.keys():
if cogIndex == self.cogIndex:
continue
if self.sameGoal(cogIndex):
dist = self.canISee(cogIndex)
if dist != self.Infinity:
self.addToVisibleList(cogIndex)
if dist < self.distToNearestFlockmate:
self.nearestFlockmate = cogIndex
self.distToNearestFlockmate = dist
return self.numFlockmatesSeen
def clearVisibleList(self):
"""Clears the visibility list and associated fields."""
self.visibleFriendsList = []
self.numFlockmatesSeen = 0
self.nearestFlockmate = None
self.distToNearestFlockmate = self.Infinity
def addToVisibleList(self, cogIndex):
"""Add the cog to the visible list."""
# test: do we see enough buddies already?
if self.numFlockmatesSeen < self.MaxFriendsVisible:
#nope--we can add to this one to the list
self.visibleFriendsList.append(cogIndex)
self.numFlockmatesSeen += 1
if self.cogIndex == 0:
#self.notify.debug('self.numFlockmatesSeen = %s' % self.numFlockmatesSeen)
pass
def canISee(self, cogIndex):
"""Return distance if I can see the other cog, infinity otherwise"""
if self.cogIndex == cogIndex:
# well we should never see ourself
return self.Infinity
cogThief = self.game.getCogThief(cogIndex)
distance = self.suit.getDistance(cogThief.suit)
if distance < self.perceptionRange:
#self.notify.debug('%s can see %s' % (self.cogIndex, cogIndex))
return distance
# fell through; can not see it
return self.Infinity
def sameGoal(self, cogIndex):
"""Return true if we have the same goal."""
cogThief = self.game.getCogThief(cogIndex)
result = (cogThief.goalId == self.goalId) and (cogThief.goal
== self.goal)
return result
def keepDistance(self):
"""Generates a vector for a flock boid to maintain his
desired separation distance from the nearest flockmate he sees.
"""
ratio = self.distToNearestFlockmate / self.SeparationDistance
nearestThief = self.game.getCogThief(self.nearestFlockmate)
change = nearestThief.suit.getPos() - self.suit.getPos()
if ratio < self.MinUrgency:
ratio = self.MinUrgency
if ratio > self.MaxUrgency:
ratio = self.MaxUrgency
# test: are we too close to our nearest flockmate?
if self.distToNearestFlockmate < self.SeparationDistance:
#self.notify.debug('%d is too close to %d' % (self.cogIndex, self.nearestFlockmate))
# too close...move away from our neighbor
change.normalize()
change *= -(1 - ratio
) # the close we are the more we are pushed away
elif self.distToNearestFlockmate > self.SeparationDistance:
# too far away move towards our neighbor
change.normalize()
change *= ratio
else:
# in the UNLIKELY event we're exactly the right distance away, do nothing
change = Vec3(0, 0, 0)
return change
def showKaboom(self):
"""Show the kaboom graphic and sound."""
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboom.reparentTo(render)
self.kaboom.setPos(self.suit.getPos())
self.kaboom.setZ(3)
self.kaboomTrack = Parallel(
SoundInterval(self.kaboomSound, volume=0.5),
Sequence(
Func(self.kaboom.showThrough),
LerpScaleInterval(self.kaboom,
duration=0.5,
scale=Point3(10, 10, 10),
startScale=Point3(1, 1, 1),
blendType='easeOut'),
Func(self.kaboom.hide),
))
self.kaboomTrack.start()
def showSplat(self):
"""Show the splat graphic and sound."""
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.splat.reparentTo(render)
self.splat.setPos(self.suit.getPos())
self.splat.setZ(3)
self.kaboomTrack = Parallel(
SoundInterval(self.pieHitSound, volume=1.0),
Sequence(
Func(self.splat.showThrough),
LerpScaleInterval(self.splat,
duration=0.5,
scale=1.75,
startScale=Point3(0.1, 0.1, 0.1),
blendType='easeOut'),
Func(self.splat.hide),
))
self.kaboomTrack.start()
class PartyCog(FSM):
notify = directNotify.newCategory('PartyCog')
HpTextGenerator = TextNode('HpTextGenerator')
hpText = None
height = 7
def __init__(self, parentNode, id, bounceSpeed = 3, bounceHeight = 1, rotateSpeed = 1, heightShift = 1, xMoveSpeed = 0, xMoveDistance = 0, bounceOffset = 0):
self.id = id
FSM.__init__(self, 'PartyCogFSM-%d' % self.id)
self.showFacingStatus = False
self.xMoveSpeed = xMoveSpeed
self.xMoveDistance = xMoveDistance
self.heightShift = heightShift
self.bounceSpeed = bounceSpeed
self.bounceHeight = bounceHeight
self.rotateSpeed = rotateSpeed
self.parentNode = parentNode
self.bounceOffset = bounceOffset
self.hitInterval = None
self.kaboomTrack = None
self.resetRollIval = None
self.netTimeSentToStartByHit = 0
self.load()
self.request('Down')
return
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.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 unload(self):
self.request('Off')
self.clearHitInterval()
if self.hole is not None:
self.hole.removeNode()
self.hole = None
if self.actor is not None:
self.actor.cleanup()
self.actor.removeNode()
self.actor = None
if self.root is not None:
self.root.removeNode()
self.root = None
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboomTrack = None
if self.resetRollIval is not None and self.resetRollIval.isPlaying():
self.resetRollIval.finish()
self.resetRollIval = None
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.finish()
self.hitInterval = None
del self.upSound
del self.pieHitSound
return
def enterStatic(self):
pass
def exitStatic(self):
pass
def enterActive(self, startTime):
self.root.setR(0.0)
updateTask = Task.Task(self.updateTask)
updateTask.startTime = startTime
taskMgr.add(updateTask, 'PartyCog.update-%d' % self.id)
def exitActive(self):
taskMgr.remove('PartyCog.update-%d' % self.id)
taskMgr.remove('PartyCog.bounceTask-%d' % self.id)
self.clearHitInterval()
self.resetRollIval = self.root.hprInterval(0.5, Point3(self.root.getH(), 0.0, 0.0), blendType='easeInOut')
self.resetRollIval.start()
self.actor.stop()
def enterDown(self):
if self.oldState == 'Off':
downAnimControl = self.actor.getAnimControl('down')
self.actor.pose('down', downAnimControl.getNumFrames() - 1)
return
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(LerpFunc(self.setAlongSpline, duration=1.0, fromData=self.currentT, toData=0.0), LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel(SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'down', loop=0)), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut'))
self.hitInterval.start()
def exitDown(self):
self.root.setR(0.0)
self.root.setH(0.0)
self.targetDistance = 0.0
self.targetFacing = 0.0
self.currentT = 0.0
self.setAlongSpline(0.0)
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(LerpScaleInterval(self.hole, duration=0.175, scale=endScale, startScale=startScale, blendType='easeIn'), Parallel(SoundInterval(self.upSound, volume=0.6, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), ActorInterval(self.actor, 'up', loop=0)), Func(self.actor.loop, 'idle'), LerpScaleInterval(self.hole, duration=0.175, scale=Point3(3, 3, 3), startScale=endScale, blendType='easeOut'))
self.hitInterval.start()
def filterDown(self, request, args):
if request == 'Down':
return None
else:
return self.defaultFilter(request, args)
return None
def setEndPoints(self, start, end, amplitude = 1.7):
self.sinAmplitude = amplitude
self.sinPeriod = (end.getX() - start.getX()) / 2
self.sinDisplacement = start.getY()
self.startPoint = start
self.endPoint = end
self.currentT = 0.0
self.targetDistance = 0.0
self.currentFacing = 0.0
self.targetFacing = 0.0
self.setAlongSpline(self.currentT)
self.hole.setPos(self.root.getPos())
self.hole.setZ(0.02)
def rockBackAndForth(self, task):
t = task.startTime + task.time
angle = math.sin(t) * 20.0
self.root.setR(angle)
return task.cont
def updateDistance(self, distance):
self.targetDistance = clamp(distance, -1.0, 1.0)
def updateTask(self, task):
self.rockBackAndForth(task)
if self.targetDistance > self.currentT:
self.currentT += min(0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
elif self.targetDistance < self.currentT:
self.currentT += max(-0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
if self.currentT < 0.0:
self.targetFacing = -90.0
elif self.currentT > 0.0:
self.targetFacing = 90.0
else:
self.targetFacing = 0.0
if self.targetFacing > self.currentFacing:
self.currentFacing += min(10, self.targetFacing - self.currentFacing)
elif self.targetFacing < self.currentFacing:
self.currentFacing += max(-10, self.targetFacing - self.currentFacing)
self.root.setH(self.currentFacing)
return task.cont
def setAlongSpline(self, t):
t = t + 1.0
dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0
x = self.startPoint.getX() + t * dist
y = self.startPoint.getY() - math.sin(t * 2 * math.pi) * self.sinAmplitude
self.root.setPos(x, y, 0)
def startBounce(self):
taskMgr.add(self.bounce, 'PartyCog.bounceTask-%d' % self.id)
def bounce(self, task):
self.root.setZ(math.sin((self.bounceOffset + task.time) * self.bounceSpeed) * self.bounceHeight + self.heightShift)
return task.cont
def setPos(self, position):
self.root.setPos(position)
def respondToPieHit(self, timestamp, position, hot = False, direction = 1.0):
if self.netTimeSentToStartByHit < timestamp:
self.__showSplat(position, direction, hot)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug('respondToPieHit self.netTimeSentToStartByHit = %s' % self.netTimeSentToStartByHit)
def clearHitInterval(self):
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.clearToInitial()
return
def __showSplat(self, position, direction, hot = False):
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.clearHitInterval()
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splat.reparentTo(render)
self.splat.setPos(self.root, position)
self.splat.setAlphaScale(1.0)
if not direction == 1.0:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0])
if self.currentFacing > 0.0:
facing = 'HitFront'
else:
facing = 'HitBack'
else:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1])
if self.currentFacing > 0.0:
facing = 'HitBack'
else:
facing = 'HitFront'
if hot:
targetscale = 0.75
part = 'head'
else:
targetscale = 0.5
part = 'body'
def setSplatAlpha(amount):
self.splat.setAlphaScale(amount)
self.hitInterval = Sequence(ActorInterval(self.actor, part + facing, loop=0), Func(self.actor.loop, 'idle'))
self.hitInterval.start()
self.kaboomTrack = Parallel(SoundInterval(self.pieHitSound, volume=1.0, node=self.actor, cutOff=PartyGlobals.PARTY_COG_CUTOFF), Sequence(Func(self.splat.showThrough), Parallel(Sequence(LerpScaleInterval(self.splat, duration=0.175, scale=targetscale, startScale=Point3(0.1, 0.1, 0.1), blendType='easeOut'), Wait(0.175)), Sequence(Wait(0.1), LerpFunc(setSplatAlpha, duration=1.0, fromData=1.0, toData=0.0, blendType='easeOut'))), Func(self.splat.cleanup), Func(self.splat.removeNode)))
self.kaboomTrack.start()
return
def showHitScore(self, number, scale = 1):
if number <= 0:
return
if self.hpText:
self.hideHitScore()
self.HpTextGenerator.setFont(ToontownGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = 1
g = 1
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = render.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
self.hpText.setPos(self.root, 0, 0, self.height / 2)
seq = Sequence(self.hpText.posInterval(0.25, Point3(self.root.getX(render), self.root.getY(render), self.root.getZ(render) + self.height + 1.0), blendType='easeOut'), Wait(0.25), self.hpText.colorInterval(0.1, Vec4(r, g, b, 0)), Func(self.__hideHitScore))
seq.start()
def hideHitScore(self):
if self.hpText:
taskMgr.remove('PartyCogHpText' + str(self.id))
self.hpText.removeNode()
self.hpText = None
return
def getHeadLocation(self):
self.actor.getJoints(jointName='head')[0].getNetTransform(self.temp_transform)
self.head_locator.setMat(self.temp_transform)
return self.head_locator.getZ(self.root)
class CogdoMazeDrop(NodePath, DirectObject):
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 disableCollisionDamage(self):
self.collTube.setTangible(1)
self.collTube.setRadius(Globals.DroppedCollisionRadius)
self.collNode.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.collNodePath.setTag('isFalling', str('False'))
def getDropIval(self):
shadow = self.shadow
drop = self.drop
id = self.id
hangTime = Globals.ShadowTime
dropTime = Globals.DropTime
dropHeight = Globals.DropHeight
targetShadowScale = 0.5
targetShadowAlpha = 0.4
shadowScaleIval = LerpScaleInterval(shadow, dropTime, targetShadowScale, startScale=0)
shadowAlphaIval = LerpColorScaleInterval(shadow, hangTime, Point4(1, 1, 1, targetShadowAlpha), startColorScale=Point4(1, 1, 1, 0))
shadowIval = Parallel(shadowScaleIval, shadowAlphaIval)
startPos = Point3(0, 0, dropHeight)
drop.setPos(startPos)
dropIval = LerpPosInterval(drop, dropTime, Point3(0, 0, 0), startPos=startPos, blendType='easeIn')
dropSoundIval = self._dropSfx
dropSoundIval.node = self
self.drop.setTransparency(1)
def _setRandScale(t):
self.drop.setScale(self, 1 - random.random() / 16, 1 - random.random() / 16, 1 - random.random() / 4)
scaleChange = 0.4 + random.random() / 4
dropShakeSeq = Sequence(LerpScaleInterval(self.drop, 0.25, Vec3(1.0 + scaleChange, 1.0 + scaleChange / 2, 1.0 - scaleChange), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.25, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), Func(self.disableCollisionDamage), LerpScaleInterval(self.drop, 0.2, Vec3(1.0 + scaleChange / 8, 1.0 + scaleChange / 8, 1.0 - scaleChange / 8), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.2, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.15, Vec3(1.0 + scaleChange / 16, 1.0 + scaleChange / 16, 1.0 - scaleChange / 16), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.15, Vec3(1.0, 1.0, 1.0), blendType='easeInOut'), LerpScaleInterval(self.drop, 0.1, Vec3(1.0 + scaleChange / 16, 1.0 + scaleChange / 8, 1.0 - scaleChange / 16), blendType='easeInOut'), LerpColorScaleInterval(self.drop, Globals.DropFadeTime, Vec4(1.0, 1.0, 1.0, 0.0)))
ival = Sequence(Func(self.reparentTo, render), Parallel(Sequence(WaitInterval(hangTime), dropIval), shadowIval), Parallel(Func(self.game.dropHit, self, id), dropSoundIval, dropShakeSeq), Func(self.game.cleanupDrop, id), name='drop%s' % id)
self.ival = ival
return ival
def destroy(self):
self.ival.pause()
self.ival = None
self._dropSfx.pause()
self._dropSfx = None
self.collTube = None
self.collNode = None
self.collNodePath.removeNode()
self.collNodePath = None
self.removeNode()
return
def loadModels(self):
# load the tug of war play area
self.playArea = loader.loadModel(
"phase_13/models/parties/partyTugOfWar")
# reparent to the party ground root
self.playArea.reparentTo(self.root)
# place the activity sign
self.sign.reparentTo(self.playArea.find("**/TugOfWar_sign_locator"))
# define initial positions, with index 0 being closest to the other team
self.dockPositions = [
[], # left team positions
[], # right team positions
]
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 = [
[], # left team positions
[], # right team positions
]
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())
# load positions for when toons fall into the water
for i in range(1, 5):
pos = self.playArea.find("**/fallenToon%d_locator" % i).getPos()
self.fallenPositions.append(pos)
# load collision that allows toons to play the game
# create one for each dock that lets toons join a particular team
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()
# Get the rope texture by extracting it from its model.
ropeModel = loader.loadModel(
"phase_4/models/minigames/tug_of_war_rope")
self.ropeTexture = ropeModel.findTexture("*")
ropeModel.removeNode()
# create as many ropes as we will ever need
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)
# Splash object for when toon hits the water
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()
class PartyCog(FSM):
notify = directNotify.newCategory("PartyCog")
HpTextGenerator = TextNode("HpTextGenerator")
hpText = None
height = 7
def __init__(self,
parentNode,
id,
bounceSpeed=3,
bounceHeight=1,
rotateSpeed=1,
heightShift=1,
xMoveSpeed=0,
xMoveDistance=0,
bounceOffset=0):
self.id = id
FSM.__init__(self, "PartyCogFSM-%d" % self.id)
self.showFacingStatus = False
self.xMoveSpeed = xMoveSpeed
self.xMoveDistance = xMoveDistance
self.heightShift = heightShift
self.bounceSpeed = bounceSpeed
self.bounceHeight = bounceHeight
self.rotateSpeed = rotateSpeed
self.parentNode = parentNode
self.bounceOffset = bounceOffset
self.hitInterval = None
self.kaboomTrack = None
self.resetRollIval = None
self.netTimeSentToStartByHit = 0
self.load()
self.request("Down")
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.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)
# Cog's Left Arm
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)
# Cog's Right Arm
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.mp3')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.mp3')
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 unload(self):
self.request("Off")
self.clearHitInterval()
if self.hole is not None:
self.hole.removeNode()
self.hole = None
if self.actor is not None:
self.actor.cleanup()
self.actor.removeNode()
self.actor = None
if self.root is not None:
self.root.removeNode()
self.root = None
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboomTrack = None
if self.resetRollIval is not None and self.resetRollIval.isPlaying():
self.resetRollIval.finish()
self.resetRollIval = None
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.finish()
self.hitInterval = None
del self.upSound
del self.pieHitSound
#===============================================================================
# FSM States
#===============================================================================
def enterStatic(self):
pass
def exitStatic(self):
pass
def enterActive(self, startTime):
self.root.setR(0.0)
updateTask = Task.Task(self.updateTask)
updateTask.startTime = startTime
taskMgr.add(updateTask, "PartyCog.update-%d" % self.id)
def exitActive(self):
taskMgr.remove("PartyCog.update-%d" % self.id)
taskMgr.remove("PartyCog.bounceTask-%d" % self.id)
self.clearHitInterval()
self.resetRollIval = self.root.hprInterval(0.5,
Point3(
self.root.getH(), 0.0,
0.0),
blendType="easeInOut")
self.resetRollIval.start()
self.actor.stop()
def enterDown(self):
if self.oldState == "Off":
downAnimControl = self.actor.getAnimControl("down")
self.actor.pose("down", downAnimControl.getNumFrames() - 1)
return
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(
LerpFunc(self.setAlongSpline,
duration=1.0,
fromData=self.currentT,
toData=0.0),
LerpScaleInterval(self.hole,
duration=0.175,
scale=endScale,
startScale=startScale,
blendType="easeIn"),
Parallel(
SoundInterval(self.upSound,
volume=0.6,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
ActorInterval(self.actor, "down", loop=0),
),
LerpScaleInterval(self.hole,
duration=0.175,
scale=Point3(3, 3, 3),
startScale=endScale,
blendType="easeOut"),
)
self.hitInterval.start()
def exitDown(self):
self.root.setR(0.0)
self.root.setH(0.0)
self.targetDistance = 0.0
self.targetFacing = 0.0
self.currentT = 0.0
self.setAlongSpline(0.0)
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(
LerpScaleInterval(self.hole,
duration=0.175,
scale=endScale,
startScale=startScale,
blendType="easeIn"),
Parallel(
SoundInterval(self.upSound,
volume=0.6,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
ActorInterval(self.actor, "up", loop=0),
),
Func(self.actor.loop, "idle"),
LerpScaleInterval(self.hole,
duration=0.175,
scale=Point3(3, 3, 3),
startScale=endScale,
blendType="easeOut"),
)
self.hitInterval.start()
def filterDown(self, request, args):
if request == "Down":
return None
else:
return self.defaultFilter(request, args)
#------------------------------------------------------------------------------
def setEndPoints(self, start, end, amplitude=1.7):
self.sinAmplitude = amplitude
self.sinPeriod = (end.getX() - start.getX()) / 2
self.sinDisplacement = start.getY()
self.startPoint = start
self.endPoint = end
self.currentT = 0.0
self.targetDistance = 0.0
self.currentFacing = 0.0
self.targetFacing = 0.0
self.setAlongSpline(self.currentT)
self.hole.setPos(self.root.getPos())
self.hole.setZ(0.02)
def rockBackAndForth(self, task):
t = task.startTime + task.time
angle = math.sin(t) * 20.0
self.root.setR(angle)
# if self.id == 0:
# print angle
return task.cont
def updateDistance(self, distance):
self.targetDistance = clamp(distance, -1.0, 1.0)
def updateTask(self, task):
self.rockBackAndForth(task)
if self.targetDistance > self.currentT:
self.currentT += min(0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
elif self.targetDistance < self.currentT:
self.currentT += max(-0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
if self.currentT < 0.0:
self.targetFacing = -90.0
elif self.currentT > 0.0:
self.targetFacing = 90.0
else:
self.targetFacing = 0.0
if self.targetFacing > self.currentFacing:
self.currentFacing += min(10,
self.targetFacing - self.currentFacing)
elif self.targetFacing < self.currentFacing:
self.currentFacing += max(-10,
self.targetFacing - self.currentFacing)
self.root.setH(self.currentFacing)
return task.cont
def setAlongSpline(self, t):
t = t + 1.0
dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0
x = self.startPoint.getX() + t * dist
y = self.startPoint.getY() - math.sin(
t * 2 * math.pi) * self.sinAmplitude
self.root.setPos(x, y, 0)
def startBounce(self):
taskMgr.add(self.bounce, "PartyCog.bounceTask-%d" % self.id)
def bounce(self, task):
#self.root.setH(self.root.getH() - self.rotateSpeed)
self.root.setZ((math.sin((self.bounceOffset + task.time) *
self.bounceSpeed) * self.bounceHeight) +
self.heightShift)
return task.cont
def setPos(self, position):
self.root.setPos(position)
def respondToPieHit(self, timestamp, position, hot=False, direction=1.0):
"""The toon hit us, react appropriately."""
assert (self.notify.debugStateCall(self))
if self.netTimeSentToStartByHit < timestamp:
self.__showSplat(position, direction, hot)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
#self.notify.debug('localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToPieHit' % (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug(
'respondToPieHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def clearHitInterval(self):
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.clearToInitial()
def __showSplat(self, position, direction, hot=False):
"""Show the splat graphic and sound."""
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.clearHitInterval()
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splat.reparentTo(render)
self.splat.setPos(self.root, position)
self.splat.setAlphaScale(1.0)
if not direction == 1.0:
#self.splat.setColorScale(Vec4(0.0, 0.0, 50.0, 1.0))
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0])
if self.currentFacing > 0.0:
facing = "HitFront"
else:
facing = "HitBack"
else:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1])
#self.splat.setColorScale(Vec4(1.0, 0.6, 0.08, 1.0))
if self.currentFacing > 0.0:
facing = "HitBack"
else:
facing = "HitFront"
if hot:
targetscale = 0.75
part = "head"
else:
targetscale = 0.5
part = "body"
def setSplatAlpha(amount):
self.splat.setAlphaScale(amount)
self.hitInterval = Sequence(
ActorInterval(self.actor, part + facing, loop=0),
Func(self.actor.loop, "idle"),
)
self.hitInterval.start()
self.kaboomTrack = Parallel(
SoundInterval(self.pieHitSound,
volume=1.0,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
Sequence(
Func(self.splat.showThrough),
Parallel(
Sequence(
LerpScaleInterval(self.splat,
duration=0.175,
scale=targetscale,
startScale=Point3(0.1, 0.1, 0.1),
blendType="easeOut"),
Wait(0.175),
),
Sequence(
Wait(0.1),
LerpFunc(
setSplatAlpha,
duration=1.0, #0.4,
fromData=1.0,
toData=0.0,
blendType="easeOut"))),
Func(self.splat.cleanup),
Func(self.splat.removeNode),
))
self.kaboomTrack.start()
def showHitScore(self, number, scale=1):
"""
Shows the hit score.
Borrowed from otp.avatar.DistributedAvatar.showHpText
"""
if number <= 0:
return
# Get rid of the number if it is already there.
if self.hpText:
self.hideHitScore()
# Set the font
self.HpTextGenerator.setFont(ToontownGlobals.getSignFont())
# Show both negative and positive signs
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText("+" + str(number))
# No shadow
self.HpTextGenerator.clearShadow()
# Center the number
self.HpTextGenerator.setAlign(TextNode.ACenter)
# Red, always
#if number < 0:
r = 1 #0.9
g = 1 #0
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
# Put the hpText over the head of the avatar
self.hpText = render.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
# Make sure it is a billboard
self.hpText.setBillboardPointEye()
# Render it after other things in the scene.
self.hpText.setBin('fixed', 100)
# Initial position ... Center of the body... the "tan tien"
self.hpText.setPos(self.root, 0, 0, self.height / 2)
# Black magic from the early days of Panda3D, later replaced by a Sequence
seq = Task.sequence(
# Fly the number out of the character
self.hpText.lerpPos(Point3(
self.root.getX(render), self.root.getY(render),
self.root.getZ(render) + self.height + 1.0),
0.25,
blendType='easeOut'),
Task.pause(0.25),
# Fade the number
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1),
# Get rid of the number
Task.Task(self.__hideHitScoreTask))
taskMgr.add(seq, "PartyCogHpText" + str(self.id))
def __hideHitScoreTask(self, task):
self.hideHitScore()
return Task.done
def hideHitScore(self):
if self.hpText:
taskMgr.remove("PartyCogHpText" + str(self.id))
self.hpText.removeNode()
self.hpText = None
def getHeadLocation(self):
(self.actor.getJoints(jointName="head")[0]).getNetTransform(
self.temp_transform)
self.head_locator.setMat(self.temp_transform)
#print self.head_locator.getZ()
return self.head_locator.getZ(self.root)
class PartyCog(FSM):
notify = directNotify.newCategory('PartyCog')
HpTextGenerator = TextNode('HpTextGenerator')
hpText = None
height = 7
def __init__(self,
parentNode,
id,
bounceSpeed=3,
bounceHeight=1,
rotateSpeed=1,
heightShift=1,
xMoveSpeed=0,
xMoveDistance=0,
bounceOffset=0):
self.id = id
FSM.__init__(self, 'PartyCogFSM-%d' % self.id)
self.showFacingStatus = False
self.xMoveSpeed = xMoveSpeed
self.xMoveDistance = xMoveDistance
self.heightShift = heightShift
self.bounceSpeed = bounceSpeed
self.bounceHeight = bounceHeight
self.rotateSpeed = rotateSpeed
self.parentNode = parentNode
self.bounceOffset = bounceOffset
self.hitInterval = None
self.kaboomTrack = None
self.resetRollIval = None
self.netTimeSentToStartByHit = 0
self.load()
self.request('Down')
return
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.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 unload(self):
self.request('Off')
self.clearHitInterval()
if self.hole is not None:
self.hole.removeNode()
self.hole = None
if self.actor is not None:
self.actor.cleanup()
self.actor.removeNode()
self.actor = None
if self.root is not None:
self.root.removeNode()
self.root = None
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboomTrack = None
if self.resetRollIval is not None and self.resetRollIval.isPlaying():
self.resetRollIval.finish()
self.resetRollIval = None
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.finish()
self.hitInterval = None
del self.upSound
del self.pieHitSound
return
def enterStatic(self):
pass
def exitStatic(self):
pass
def enterActive(self, startTime):
self.root.setR(0.0)
updateTask = Task.Task(self.updateTask)
updateTask.startTime = startTime
taskMgr.add(updateTask, 'PartyCog.update-%d' % self.id)
def exitActive(self):
taskMgr.remove('PartyCog.update-%d' % self.id)
taskMgr.remove('PartyCog.bounceTask-%d' % self.id)
self.clearHitInterval()
self.resetRollIval = self.root.hprInterval(0.5,
Point3(
self.root.getH(), 0.0,
0.0),
blendType='easeInOut')
self.resetRollIval.start()
self.actor.stop()
def enterDown(self):
if self.oldState == 'Off':
downAnimControl = self.actor.getAnimControl('down')
self.actor.pose('down', downAnimControl.getNumFrames() - 1)
return
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(
LerpFunc(self.setAlongSpline,
duration=1.0,
fromData=self.currentT,
toData=0.0),
LerpScaleInterval(self.hole,
duration=0.175,
scale=endScale,
startScale=startScale,
blendType='easeIn'),
Parallel(
SoundInterval(self.upSound,
volume=0.6,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
ActorInterval(self.actor, 'down', loop=0)),
LerpScaleInterval(self.hole,
duration=0.175,
scale=Point3(3, 3, 3),
startScale=endScale,
blendType='easeOut'))
self.hitInterval.start()
def exitDown(self):
self.root.setR(0.0)
self.root.setH(0.0)
self.targetDistance = 0.0
self.targetFacing = 0.0
self.currentT = 0.0
self.setAlongSpline(0.0)
self.clearHitInterval()
startScale = self.hole.getScale()
endScale = Point3(5, 5, 5)
self.hitInterval = Sequence(
LerpScaleInterval(self.hole,
duration=0.175,
scale=endScale,
startScale=startScale,
blendType='easeIn'),
Parallel(
SoundInterval(self.upSound,
volume=0.6,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
ActorInterval(self.actor, 'up', loop=0)),
Func(self.actor.loop, 'idle'),
LerpScaleInterval(self.hole,
duration=0.175,
scale=Point3(3, 3, 3),
startScale=endScale,
blendType='easeOut'))
self.hitInterval.start()
def filterDown(self, request, args):
if request == 'Down':
return None
else:
return self.defaultFilter(request, args)
return None
def setEndPoints(self, start, end, amplitude=1.7):
self.sinAmplitude = amplitude
self.sinPeriod = (end.getX() - start.getX()) / 2
self.sinDisplacement = start.getY()
self.startPoint = start
self.endPoint = end
self.currentT = 0.0
self.targetDistance = 0.0
self.currentFacing = 0.0
self.targetFacing = 0.0
self.setAlongSpline(self.currentT)
self.hole.setPos(self.root.getPos())
self.hole.setZ(0.02)
def rockBackAndForth(self, task):
t = task.startTime + task.time
angle = math.sin(t) * 20.0
self.root.setR(angle)
return task.cont
def updateDistance(self, distance):
self.targetDistance = clamp(distance, -1.0, 1.0)
def updateTask(self, task):
self.rockBackAndForth(task)
if self.targetDistance > self.currentT:
self.currentT += min(0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
elif self.targetDistance < self.currentT:
self.currentT += max(-0.01, self.targetDistance - self.currentT)
self.setAlongSpline(self.currentT)
if self.currentT < 0.0:
self.targetFacing = -90.0
elif self.currentT > 0.0:
self.targetFacing = 90.0
else:
self.targetFacing = 0.0
if self.targetFacing > self.currentFacing:
self.currentFacing += min(10,
self.targetFacing - self.currentFacing)
elif self.targetFacing < self.currentFacing:
self.currentFacing += max(-10,
self.targetFacing - self.currentFacing)
self.root.setH(self.currentFacing)
return task.cont
def setAlongSpline(self, t):
t = t + 1.0
dist = (self.endPoint.getX() - self.startPoint.getX()) / 2.0
x = self.startPoint.getX() + t * dist
y = self.startPoint.getY() - math.sin(
t * 2 * math.pi) * self.sinAmplitude
self.root.setPos(x, y, 0)
def startBounce(self):
taskMgr.add(self.bounce, 'PartyCog.bounceTask-%d' % self.id)
def bounce(self, task):
self.root.setZ(
math.sin((self.bounceOffset + task.time) * self.bounceSpeed) *
self.bounceHeight + self.heightShift)
return task.cont
def setPos(self, position):
self.root.setPos(position)
def respondToPieHit(self, timestamp, position, hot=False, direction=1.0):
if self.netTimeSentToStartByHit < timestamp:
self.__showSplat(position, direction, hot)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug(
'respondToPieHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def clearHitInterval(self):
if self.hitInterval is not None and self.hitInterval.isPlaying():
self.hitInterval.clearToInitial()
return
def __showSplat(self, position, direction, hot=False):
if self.kaboomTrack is not None and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.clearHitInterval()
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splat.reparentTo(render)
self.splat.setPos(self.root, position)
self.splat.setAlphaScale(1.0)
if not direction == 1.0:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[0])
if self.currentFacing > 0.0:
facing = 'HitFront'
else:
facing = 'HitBack'
else:
self.splat.setColorScale(PartyGlobals.CogActivitySplatColors[1])
if self.currentFacing > 0.0:
facing = 'HitBack'
else:
facing = 'HitFront'
if hot:
targetscale = 0.75
part = 'head'
else:
targetscale = 0.5
part = 'body'
def setSplatAlpha(amount):
self.splat.setAlphaScale(amount)
self.hitInterval = Sequence(
ActorInterval(self.actor, part + facing, loop=0),
Func(self.actor.loop, 'idle'))
self.hitInterval.start()
self.kaboomTrack = Parallel(
SoundInterval(self.pieHitSound,
volume=1.0,
node=self.actor,
cutOff=PartyGlobals.PARTY_COG_CUTOFF),
Sequence(
Func(self.splat.showThrough),
Parallel(
Sequence(
LerpScaleInterval(self.splat,
duration=0.175,
scale=targetscale,
startScale=Point3(0.1, 0.1, 0.1),
blendType='easeOut'), Wait(0.175)),
Sequence(
Wait(0.1),
LerpFunc(setSplatAlpha,
duration=1.0,
fromData=1.0,
toData=0.0,
blendType='easeOut'))),
Func(self.splat.cleanup), Func(self.splat.removeNode)))
self.kaboomTrack.start()
return
def showHitScore(self, number, scale=1):
if number <= 0:
return
if self.hpText:
self.hideHitScore()
self.HpTextGenerator.setFont(ToontownGlobals.getSignFont())
if number < 0:
self.HpTextGenerator.setText(str(number))
else:
self.HpTextGenerator.setText('+' + str(number))
self.HpTextGenerator.clearShadow()
self.HpTextGenerator.setAlign(TextNode.ACenter)
r = 1
g = 1
b = 0
a = 1
self.HpTextGenerator.setTextColor(r, g, b, a)
self.hpTextNode = self.HpTextGenerator.generate()
self.hpText = render.attachNewNode(self.hpTextNode)
self.hpText.setScale(scale)
self.hpText.setBillboardPointEye()
self.hpText.setBin('fixed', 100)
self.hpText.setPos(self.root, 0, 0, self.height / 2)
seq = Task.sequence(
self.hpText.lerpPos(Point3(
self.root.getX(render), self.root.getY(render),
self.root.getZ(render) + self.height + 1.0),
0.25,
blendType='easeOut'), Task.pause(0.25),
self.hpText.lerpColor(Vec4(r, g, b, a), Vec4(r, g, b, 0), 0.1),
Task.Task(self.__hideHitScoreTask))
taskMgr.add(seq, 'PartyCogHpText' + str(self.id))
def __hideHitScoreTask(self, task):
self.hideHitScore()
return Task.done
def hideHitScore(self):
if self.hpText:
taskMgr.remove('PartyCogHpText' + str(self.id))
self.hpText.removeNode()
self.hpText = None
return
def getHeadLocation(self):
self.actor.getJoints(jointName='head')[0].getNetTransform(
self.temp_transform)
self.head_locator.setMat(self.temp_transform)
return self.head_locator.getZ(self.root)
class CogThief(DirectObject):
notify = directNotify.newCategory('CogThief')
DefaultSpeedWalkAnim = 4.0
CollisionRadius = 1.25
MaxFriendsVisible = 4
Infinity = 100000.0
SeparationDistance = 6.0
MinUrgency = 0.5
MaxUrgency = 0.75
def __init__(self, cogIndex, suitType, game, cogSpeed):
self.cogIndex = cogIndex
self.suitType = suitType
self.game = game
self.cogSpeed = cogSpeed
suit = Suit.Suit()
d = SuitDNA.SuitDNA()
d.newSuit(suitType)
suit.setDNA(d)
suit.pose('walk', 0)
self.suit = suit
self.goal = CTGG.NoGoal
self.goalId = CTGG.InvalidGoalId
self.lastLocalTimeStampFromAI = 0
self.lastPosFromAI = Point3(0, 0, 0)
self.lastThinkTime = 0
self.doneAdjust = False
self.barrel = CTGG.NoBarrelCarried
self.signalledAtReturnPos = False
self.defaultPlayRate = 1.0
self.netTimeSentToStartByHit = 0
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
self.bodyLength = self.CollisionRadius * 2
self.cruiseDistance = 2 * self.bodyLength
self.maxVelocity = self.cogSpeed
self.maxAcceleration = 5.0
self.perceptionRange = 6
self.notify.debug('cogSpeed=%s' % self.cogSpeed)
self.kaboomSound = loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_fire_alt.mp3')
self.kaboom = loader.loadModel(
'phase_4/models/minigames/ice_game_kaboom')
self.kaboom.setScale(2.0)
self.kaboom.setBillboardPointEye()
self.kaboom.hide()
self.kaboomTrack = None
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound(
'AA_wholepie_only.mp3')
def destroy(self):
self.ignoreAll()
self.suit.delete()
self.game = None
def uniqueName(self, baseStr):
return baseStr + '-' + str(self.game.doId)
def handleEnterSphere(self, collEntry):
intoNp = collEntry.getIntoNodePath()
self.notify.debug('handleEnterSphere suit %d hit %s' %
(self.cogIndex, intoNp))
if self.game:
self.game.handleEnterSphere(collEntry)
def gameStart(self, gameStartTime):
self.gameStartTime = gameStartTime
self.initCollisions()
self.startWalkAnim()
def gameEnd(self):
self.moveIval.pause()
del self.moveIval
self.shutdownCollisions()
self.suit.loop('neutral')
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 shutdownCollisions(self):
self.ignore(self.uniqueName('enter' + self.collSphereName))
del self.collSphere
self.collNodePath.removeNode()
del self.collNodePath
del self.collNode
def updateGoal(self, timestamp, inResponseClientStamp, goalType, goalId,
pos):
self.notify.debug('self.netTimeSentToStartByHit =%s' %
self.netTimeSentToStartByHit)
if not self.game:
self.notify.debug('updateGoal self.game is None, just returning')
return None
if not self.suit:
self.notify.debug('updateGoal self.suit is None, just returning')
return None
if self.goal == CTGG.NoGoal:
self.startWalkAnim()
if goalType == CTGG.NoGoal:
self.notify.debug('updateGoal setting position to %s' % pos)
self.suit.setPos(pos)
self.lastThinkTime = 0
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
if goalType == CTGG.RunAwayGoal:
pass
1
if inResponseClientStamp < self.netTimeSentToStartByHit and self.goal == CTGG.NoGoal and goalType == CTGG.RunAwayGoal:
self.notify.warning(
'ignoring newGoal %s as cog %d was recently hit responsetime=%s hitTime=%s'
% (CTGG.GoalStr[goalType], self.cogIndex,
inResponseClientStamp, self.netTimeSentToStartByHit))
else:
self.lastLocalTimeStampFromAI = globalClockDelta.networkToLocalTime(
timestamp, bits=32)
self.goal = goalType
self.goalId = goalId
self.lastPosFromAI = pos
self.doneAdjust = False
self.signalledAtReturnPos = False
def startWalkAnim(self):
if self.suit:
self.suit.loop('walk')
speed = self.cogSpeed
self.defaultPlayRate = float(self.cogSpeed /
self.DefaultSpeedWalkAnim)
self.suit.setPlayRate(self.defaultPlayRate, 'walk')
def think(self):
if self.goal == CTGG.ToonGoal:
self.thinkAboutCatchingToon()
elif self.goal == CTGG.BarrelGoal:
self.thinkAboutGettingBarrel()
elif self.goal == CTGG.RunAwayGoal:
self.thinkAboutRunAway()
def thinkAboutCatchingToon(self):
if not self.game:
return None
av = self.game.getAvatar(self.goalId)
if av:
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
avPos = av.getPos()
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.notify.debug(
'thinkAboutCatchingToon not doneAdjust setting pos %s' %
myPos)
self.doneAdjust = True
self.suit.setPos(myPos)
if self.game.isToonPlayingHitTrack(self.goalId):
self.suit.headsUp(av)
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
else:
self.commonMove()
newPos = self.suit.getPos()
self.adjustPlayRate(newPos, myPos, diffTime)
self.lastThinkTime = globalClock.getFrameTime()
def convertNetworkStampToGameTime(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
gameTime = self.game.local2GameTime(localStamp)
return gameTime
def respondToToonHit(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
if self.netTimeSentToStartByHit < timestamp:
self.clearGoal()
self.showKaboom()
startPos = CTGG.CogStartingPositions[self.cogIndex]
oldPos = self.suit.getPos()
self.suit.setPos(startPos)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug(
'localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToToonHit'
% (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug(
'respondToToonHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def clearGoal(self):
self.goal = CTGG.NoGoal
self.goalId = CTGG.InvalidGoalId
def thinkAboutGettingBarrel(self):
if not self.game:
return None
if not hasattr(self.game, 'barrels'):
return None
if self.goalId not in xrange(len(self.game.barrels)):
return None
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
barrel = self.game.barrels[self.goalId]
barrelPos = barrel.getPos()
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.notify.debug(
'thinkAboutGettingBarrel not doneAdjust setting position to %s'
% myPos)
self.suit.setPos(myPos)
self.doneAdjust = True
displacement = barrelPos - myPos
distanceToToon = displacement.length()
self.suit.headsUp(barrel)
lengthTravelled = diffTime * self.cogSpeed
if lengthTravelled > distanceToToon:
lengthTravelled = distanceToToon
displacement.normalize()
dirVector = displacement
dirVector *= lengthTravelled
newPos = myPos + dirVector
newPos.setZ(0)
self.suit.setPos(newPos)
self.adjustPlayRate(newPos, myPos, diffTime)
self.lastThinkTime = globalClock.getFrameTime()
def stopWalking(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
if localStamp > self.lastLocalTimeStampFromAI:
self.suit.loop('neutral')
self.clearGoal()
def thinkAboutRunAway(self):
if not self.game:
return None
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
returnPos = CTGG.CogReturnPositions[self.goalId]
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.suit.setPos(myPos)
self.doneAdjust = True
displacement = returnPos - myPos
distanceToToon = displacement.length()
tempNp = render.attachNewNode('tempRet')
tempNp.setPos(returnPos)
self.suit.headsUp(tempNp)
tempNp.removeNode()
lengthTravelled = diffTime * self.cogSpeed
if lengthTravelled > distanceToToon:
lengthTravelled = distanceToToon
displacement.normalize()
dirVector = displacement
dirVector *= lengthTravelled
newPos = myPos + dirVector
newPos.setZ(0)
self.suit.setPos(newPos)
self.adjustPlayRate(newPos, myPos, diffTime)
if (self.suit.getPos() - returnPos).length() < 0.0001:
if not (self.signalledAtReturnPos) and self.barrel >= 0:
self.game.sendCogAtReturnPos(self.cogIndex, self.barrel)
self.signalledAtReturnPos = True
self.lastThinkTime = globalClock.getFrameTime()
def makeCogCarryBarrel(self, timestamp, inResponseClientStamp, barrelModel,
barrelIndex, cogPos):
if not self.game:
return None
localTimeStamp = globalClockDelta.networkToLocalTime(timestamp,
bits=32)
self.lastLocalTimeStampFromAI = localTimeStamp
inResponseGameTime = self.convertNetworkStampToGameTime(
inResponseClientStamp)
self.notify.debug('inResponseGameTime =%s timeSentToStart=%s' %
(inResponseGameTime, self.netTimeSentToStartByHit))
if inResponseClientStamp < self.netTimeSentToStartByHit and self.goal == CTGG.NoGoal:
self.notify.warning('ignoring makeCogCarrybarrel')
else:
barrelModel.setPos(0, -1.0, 1.5)
barrelModel.reparentTo(self.suit)
self.suit.setPos(cogPos)
self.barrel = barrelIndex
def makeCogDropBarrel(self, timestamp, inResponseClientStamp, barrelModel,
barrelIndex, barrelPos):
localTimeStamp = globalClockDelta.networkToLocalTime(timestamp,
bits=32)
self.lastLocalTimeStampFromAI = localTimeStamp
barrelModel.reparentTo(render)
barrelModel.setPos(barrelPos)
self.barrel = CTGG.NoBarrelCarried
def respondToPieHit(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits=32)
if self.netTimeSentToStartByHit < timestamp:
self.clearGoal()
self.showSplat()
startPos = CTGG.CogStartingPositions[self.cogIndex]
oldPos = self.suit.getPos()
self.suit.setPos(startPos)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug(
'localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToPieHit'
% (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug(
'respondToPieHit self.netTimeSentToStartByHit = %s' %
self.netTimeSentToStartByHit)
def cleanup(self):
self.clearGoal()
self.ignoreAll()
self.suit.delete()
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.suit = None
self.game = None
def adjustPlayRate(self, newPos, oldPos, diffTime):
lengthTravelled = (newPos - oldPos).length()
if diffTime:
speed = lengthTravelled / diffTime
else:
speed = self.cogSpeed
rateMult = speed / self.cogSpeed
newRate = rateMult * self.defaultPlayRate
self.suit.setPlayRate(newRate, 'walk')
def commonMove(self):
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
dt = globalClock.getFrameTime() - self.lastThinkTime
self.oldpos = self.suit.getPos()
pos = self.suit.getPos()
pos += self.velocity * dt
self.suit.setPos(pos)
self.seeFriends()
acc = Vec3(0, 0, 0)
self.accumulate(acc, self.getTargetVector())
if self.numFlockmatesSeen > 0:
keepDistanceVector = self.keepDistance()
oldAcc = Vec3(acc)
self.accumulate(acc, keepDistanceVector)
if self.cogIndex == 0:
pass
if acc.length() > self.maxAcceleration:
acc.normalize()
acc *= self.maxAcceleration
self.oldVelocity = self.velocity
self.velocity += acc
if self.velocity.length() > self.maxVelocity:
self.velocity.normalize()
self.velocity *= self.maxVelocity
forwardVec = Vec3(1, 0, 0)
heading = rad2Deg(math.atan2(self.velocity[1], self.velocity[0]))
heading -= 90
self.suit.setH(heading)
def getTargetVector(self):
targetPos = Point3(0, 0, 0)
if self.goal == CTGG.ToonGoal:
av = self.game.getAvatar(self.goalId)
if av:
targetPos = av.getPos()
elif self.goal == CTGG.BarrelGoal:
barrel = self.game.barrels[self.goalId]
targetPos = barrel.getPos()
elif self.goal == CTGG.RunAwayGoal:
targetPos = CTGG.CogReturnPositions[self.goalId]
targetPos.setZ(0)
myPos = self.suit.getPos()
diff = targetPos - myPos
if diff.length() > 1.0:
diff.normalize()
diff *= 1.0
return diff
def accumulate(self, accumulator, valueToAdd):
accumulator += valueToAdd
return accumulator.length()
def seeFriends(self):
self.clearVisibleList()
for cogIndex in self.game.cogInfo.keys():
if cogIndex == self.cogIndex:
continue
if self.sameGoal(cogIndex):
dist = self.canISee(cogIndex)
if dist != self.Infinity:
self.addToVisibleList(cogIndex)
if dist < self.distToNearestFlockmate:
self.nearestFlockmate = cogIndex
self.distToNearestFlockmate = dist
dist != self.Infinity
return self.numFlockmatesSeen
def clearVisibleList(self):
self.visibleFriendsList = []
self.numFlockmatesSeen = 0
self.nearestFlockmate = None
self.distToNearestFlockmate = self.Infinity
def addToVisibleList(self, cogIndex):
if self.numFlockmatesSeen < self.MaxFriendsVisible:
self.visibleFriendsList.append(cogIndex)
self.numFlockmatesSeen += 1
if self.cogIndex == 0:
pass
def canISee(self, cogIndex):
if self.cogIndex == cogIndex:
return self.Infinity
cogThief = self.game.getCogThief(cogIndex)
distance = self.suit.getDistance(cogThief.suit)
if distance < self.perceptionRange:
return distance
return self.Infinity
def sameGoal(self, cogIndex):
cogThief = self.game.getCogThief(cogIndex)
if cogThief.goalId == self.goalId:
pass
result = cogThief.goal == self.goal
return result
def keepDistance(self):
ratio = self.distToNearestFlockmate / self.SeparationDistance
nearestThief = self.game.getCogThief(self.nearestFlockmate)
change = nearestThief.suit.getPos() - self.suit.getPos()
if ratio < self.MinUrgency:
ratio = self.MinUrgency
if ratio > self.MaxUrgency:
ratio = self.MaxUrgency
if self.distToNearestFlockmate < self.SeparationDistance:
change.normalize()
change *= -(1 - ratio)
elif self.distToNearestFlockmate > self.SeparationDistance:
change.normalize()
change *= ratio
else:
change = Vec3(0, 0, 0)
return change
def showKaboom(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboom.reparentTo(render)
self.kaboom.setPos(self.suit.getPos())
self.kaboom.setZ(3)
self.kaboomTrack = Parallel(
SoundInterval(self.kaboomSound, volume=0.5),
Sequence(
Func(self.kaboom.showThrough),
LerpScaleInterval(self.kaboom,
duration=0.5,
scale=Point3(10, 10, 10),
startScale=Point3(1, 1, 1),
blendType='easeOut'),
Func(self.kaboom.hide)))
self.kaboomTrack.start()
def showSplat(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.splat.reparentTo(render)
self.splat.setPos(self.suit.getPos())
self.splat.setZ(3)
self.kaboomTrack = Parallel(
SoundInterval(self.pieHitSound, volume=1.0),
Sequence(
Func(self.splat.showThrough),
LerpScaleInterval(self.splat,
duration=0.5,
scale=1.75,
startScale=Point3(0.10000000000000001,
0.10000000000000001,
0.10000000000000001),
blendType='easeOut'), Func(self.splat.hide)))
self.kaboomTrack.start()
class CogThief(DirectObject):
notify = directNotify.newCategory('CogThief')
DefaultSpeedWalkAnim = 4.0
CollisionRadius = 1.25
MaxFriendsVisible = 4
Infinity = 100000.0
SeparationDistance = 6.0
MinUrgency = 0.5
MaxUrgency = 0.75
def __init__(self, cogIndex, suitType, game, cogSpeed):
self.cogIndex = cogIndex
self.suitType = suitType
self.game = game
self.cogSpeed = cogSpeed
suit = Suit.Suit()
d = SuitDNA.SuitDNA()
d.newSuit(suitType)
suit.setDNA(d)
suit.pose('walk', 0)
self.suit = suit
self.goal = CTGG.NoGoal
self.goalId = CTGG.InvalidGoalId
self.lastLocalTimeStampFromAI = 0
self.lastPosFromAI = Point3(0, 0, 0)
self.lastThinkTime = 0
self.doneAdjust = False
self.barrel = CTGG.NoBarrelCarried
self.signalledAtReturnPos = False
self.defaultPlayRate = 1.0
self.netTimeSentToStartByHit = 0
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
self.bodyLength = self.CollisionRadius * 2
self.cruiseDistance = 2 * self.bodyLength
self.maxVelocity = self.cogSpeed
self.maxAcceleration = 5.0
self.perceptionRange = 6
self.notify.debug('cogSpeed=%s' % self.cogSpeed)
self.kaboomSound = loader.loadSfx('phase_4/audio/sfx/MG_cannon_fire_alt.mp3')
self.kaboom = loader.loadModel('phase_4/models/minigames/ice_game_kaboom')
self.kaboom.setScale(2.0)
self.kaboom.setBillboardPointEye()
self.kaboom.hide()
self.kaboomTrack = None
splatName = 'splat-creampie'
self.splat = globalPropPool.getProp(splatName)
self.splat.setBillboardPointEye()
self.splatType = globalPropPool.getPropType(splatName)
self.pieHitSound = globalBattleSoundCache.getSound('AA_wholepie_only.mp3')
def destroy(self):
self.ignoreAll()
self.suit.delete()
self.game = None
def uniqueName(self, baseStr):
return baseStr + '-' + str(self.game.doId)
def handleEnterSphere(self, collEntry):
intoNp = collEntry.getIntoNodePath()
self.notify.debug('handleEnterSphere suit %d hit %s' % (self.cogIndex, intoNp))
if self.game:
self.game.handleEnterSphere(collEntry)
def gameStart(self, gameStartTime):
self.gameStartTime = gameStartTime
self.initCollisions()
self.startWalkAnim()
def gameEnd(self):
self.moveIval.pause()
del self.moveIval
self.shutdownCollisions()
self.suit.loop('neutral')
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 shutdownCollisions(self):
self.ignore(self.uniqueName('enter' + self.collSphereName))
del self.collSphere
self.collNodePath.removeNode()
del self.collNodePath
del self.collNode
def updateGoal(self, timestamp, inResponseClientStamp, goalType, goalId, pos):
self.notify.debug('self.netTimeSentToStartByHit =%s' % self.netTimeSentToStartByHit)
if not self.game:
self.notify.debug('updateGoal self.game is None, just returning')
return None
if not self.suit:
self.notify.debug('updateGoal self.suit is None, just returning')
return None
if self.goal == CTGG.NoGoal:
self.startWalkAnim()
if goalType == CTGG.NoGoal:
self.notify.debug('updateGoal setting position to %s' % pos)
self.suit.setPos(pos)
self.lastThinkTime = 0
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
if goalType == CTGG.RunAwayGoal:
pass
1
if inResponseClientStamp < self.netTimeSentToStartByHit and self.goal == CTGG.NoGoal and goalType == CTGG.RunAwayGoal:
self.notify.warning('ignoring newGoal %s as cog %d was recently hit responsetime=%s hitTime=%s' % (CTGG.GoalStr[goalType], self.cogIndex, inResponseClientStamp, self.netTimeSentToStartByHit))
else:
self.lastLocalTimeStampFromAI = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
self.goal = goalType
self.goalId = goalId
self.lastPosFromAI = pos
self.doneAdjust = False
self.signalledAtReturnPos = False
def startWalkAnim(self):
if self.suit:
self.suit.loop('walk')
speed = self.cogSpeed
self.defaultPlayRate = float(self.cogSpeed / self.DefaultSpeedWalkAnim)
self.suit.setPlayRate(self.defaultPlayRate, 'walk')
def think(self):
if self.goal == CTGG.ToonGoal:
self.thinkAboutCatchingToon()
elif self.goal == CTGG.BarrelGoal:
self.thinkAboutGettingBarrel()
elif self.goal == CTGG.RunAwayGoal:
self.thinkAboutRunAway()
def thinkAboutCatchingToon(self):
if not self.game:
return None
av = self.game.getAvatar(self.goalId)
if av:
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
avPos = av.getPos()
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.notify.debug('thinkAboutCatchingToon not doneAdjust setting pos %s' % myPos)
self.doneAdjust = True
self.suit.setPos(myPos)
if self.game.isToonPlayingHitTrack(self.goalId):
self.suit.headsUp(av)
self.velocity = Vec3(0, 0, 0)
self.oldVelocity = Vec3(0, 0, 0)
self.acceleration = Vec3(0, 0, 0)
else:
self.commonMove()
newPos = self.suit.getPos()
self.adjustPlayRate(newPos, myPos, diffTime)
self.lastThinkTime = globalClock.getFrameTime()
def convertNetworkStampToGameTime(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
gameTime = self.game.local2GameTime(localStamp)
return gameTime
def respondToToonHit(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
if self.netTimeSentToStartByHit < timestamp:
self.clearGoal()
self.showKaboom()
startPos = CTGG.CogStartingPositions[self.cogIndex]
oldPos = self.suit.getPos()
self.suit.setPos(startPos)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug('localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToToonHit' % (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug('respondToToonHit self.netTimeSentToStartByHit = %s' % self.netTimeSentToStartByHit)
def clearGoal(self):
self.goal = CTGG.NoGoal
self.goalId = CTGG.InvalidGoalId
def thinkAboutGettingBarrel(self):
if not self.game:
return None
if not hasattr(self.game, 'barrels'):
return None
if self.goalId not in xrange(len(self.game.barrels)):
return None
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
barrel = self.game.barrels[self.goalId]
barrelPos = barrel.getPos()
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.notify.debug('thinkAboutGettingBarrel not doneAdjust setting position to %s' % myPos)
self.suit.setPos(myPos)
self.doneAdjust = True
displacement = barrelPos - myPos
distanceToToon = displacement.length()
self.suit.headsUp(barrel)
lengthTravelled = diffTime * self.cogSpeed
if lengthTravelled > distanceToToon:
lengthTravelled = distanceToToon
displacement.normalize()
dirVector = displacement
dirVector *= lengthTravelled
newPos = myPos + dirVector
newPos.setZ(0)
self.suit.setPos(newPos)
self.adjustPlayRate(newPos, myPos, diffTime)
self.lastThinkTime = globalClock.getFrameTime()
def stopWalking(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
if localStamp > self.lastLocalTimeStampFromAI:
self.suit.loop('neutral')
self.clearGoal()
def thinkAboutRunAway(self):
if not self.game:
return None
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
diffTime = globalClock.getFrameTime() - self.lastThinkTime
returnPos = CTGG.CogReturnPositions[self.goalId]
myPos = self.suit.getPos()
if not self.doneAdjust:
myPos = self.lastPosFromAI
self.suit.setPos(myPos)
self.doneAdjust = True
displacement = returnPos - myPos
distanceToToon = displacement.length()
tempNp = render.attachNewNode('tempRet')
tempNp.setPos(returnPos)
self.suit.headsUp(tempNp)
tempNp.removeNode()
lengthTravelled = diffTime * self.cogSpeed
if lengthTravelled > distanceToToon:
lengthTravelled = distanceToToon
displacement.normalize()
dirVector = displacement
dirVector *= lengthTravelled
newPos = myPos + dirVector
newPos.setZ(0)
self.suit.setPos(newPos)
self.adjustPlayRate(newPos, myPos, diffTime)
if (self.suit.getPos() - returnPos).length() < 0.0001:
if not (self.signalledAtReturnPos) and self.barrel >= 0:
self.game.sendCogAtReturnPos(self.cogIndex, self.barrel)
self.signalledAtReturnPos = True
self.lastThinkTime = globalClock.getFrameTime()
def makeCogCarryBarrel(self, timestamp, inResponseClientStamp, barrelModel, barrelIndex, cogPos):
if not self.game:
return None
localTimeStamp = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
self.lastLocalTimeStampFromAI = localTimeStamp
inResponseGameTime = self.convertNetworkStampToGameTime(inResponseClientStamp)
self.notify.debug('inResponseGameTime =%s timeSentToStart=%s' % (inResponseGameTime, self.netTimeSentToStartByHit))
if inResponseClientStamp < self.netTimeSentToStartByHit and self.goal == CTGG.NoGoal:
self.notify.warning('ignoring makeCogCarrybarrel')
else:
barrelModel.setPos(0, -1.0, 1.5)
barrelModel.reparentTo(self.suit)
self.suit.setPos(cogPos)
self.barrel = barrelIndex
def makeCogDropBarrel(self, timestamp, inResponseClientStamp, barrelModel, barrelIndex, barrelPos):
localTimeStamp = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
self.lastLocalTimeStampFromAI = localTimeStamp
barrelModel.reparentTo(render)
barrelModel.setPos(barrelPos)
self.barrel = CTGG.NoBarrelCarried
def respondToPieHit(self, timestamp):
localStamp = globalClockDelta.networkToLocalTime(timestamp, bits = 32)
if self.netTimeSentToStartByHit < timestamp:
self.clearGoal()
self.showSplat()
startPos = CTGG.CogStartingPositions[self.cogIndex]
oldPos = self.suit.getPos()
self.suit.setPos(startPos)
if self.netTimeSentToStartByHit < timestamp:
self.netTimeSentToStartByHit = timestamp
else:
self.notify.debug('localStamp = %s, lastLocalTimeStampFromAI=%s, ignoring respondToPieHit' % (localStamp, self.lastLocalTimeStampFromAI))
self.notify.debug('respondToPieHit self.netTimeSentToStartByHit = %s' % self.netTimeSentToStartByHit)
def cleanup(self):
self.clearGoal()
self.ignoreAll()
self.suit.delete()
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.suit = None
self.game = None
def adjustPlayRate(self, newPos, oldPos, diffTime):
lengthTravelled = (newPos - oldPos).length()
if diffTime:
speed = lengthTravelled / diffTime
else:
speed = self.cogSpeed
rateMult = speed / self.cogSpeed
newRate = rateMult * self.defaultPlayRate
self.suit.setPlayRate(newRate, 'walk')
def commonMove(self):
if not self.lastThinkTime:
self.lastThinkTime = globalClock.getFrameTime()
dt = globalClock.getFrameTime() - self.lastThinkTime
self.oldpos = self.suit.getPos()
pos = self.suit.getPos()
pos += self.velocity * dt
self.suit.setPos(pos)
self.seeFriends()
acc = Vec3(0, 0, 0)
self.accumulate(acc, self.getTargetVector())
if self.numFlockmatesSeen > 0:
keepDistanceVector = self.keepDistance()
oldAcc = Vec3(acc)
self.accumulate(acc, keepDistanceVector)
if self.cogIndex == 0:
pass
if acc.length() > self.maxAcceleration:
acc.normalize()
acc *= self.maxAcceleration
self.oldVelocity = self.velocity
self.velocity += acc
if self.velocity.length() > self.maxVelocity:
self.velocity.normalize()
self.velocity *= self.maxVelocity
forwardVec = Vec3(1, 0, 0)
heading = rad2Deg(math.atan2(self.velocity[1], self.velocity[0]))
heading -= 90
self.suit.setH(heading)
def getTargetVector(self):
targetPos = Point3(0, 0, 0)
if self.goal == CTGG.ToonGoal:
av = self.game.getAvatar(self.goalId)
if av:
targetPos = av.getPos()
elif self.goal == CTGG.BarrelGoal:
barrel = self.game.barrels[self.goalId]
targetPos = barrel.getPos()
elif self.goal == CTGG.RunAwayGoal:
targetPos = CTGG.CogReturnPositions[self.goalId]
targetPos.setZ(0)
myPos = self.suit.getPos()
diff = targetPos - myPos
if diff.length() > 1.0:
diff.normalize()
diff *= 1.0
return diff
def accumulate(self, accumulator, valueToAdd):
accumulator += valueToAdd
return accumulator.length()
def seeFriends(self):
self.clearVisibleList()
for cogIndex in self.game.cogInfo.keys():
if cogIndex == self.cogIndex:
continue
if self.sameGoal(cogIndex):
dist = self.canISee(cogIndex)
if dist != self.Infinity:
self.addToVisibleList(cogIndex)
if dist < self.distToNearestFlockmate:
self.nearestFlockmate = cogIndex
self.distToNearestFlockmate = dist
dist != self.Infinity
return self.numFlockmatesSeen
def clearVisibleList(self):
self.visibleFriendsList = []
self.numFlockmatesSeen = 0
self.nearestFlockmate = None
self.distToNearestFlockmate = self.Infinity
def addToVisibleList(self, cogIndex):
if self.numFlockmatesSeen < self.MaxFriendsVisible:
self.visibleFriendsList.append(cogIndex)
self.numFlockmatesSeen += 1
if self.cogIndex == 0:
pass
def canISee(self, cogIndex):
if self.cogIndex == cogIndex:
return self.Infinity
cogThief = self.game.getCogThief(cogIndex)
distance = self.suit.getDistance(cogThief.suit)
if distance < self.perceptionRange:
return distance
return self.Infinity
def sameGoal(self, cogIndex):
cogThief = self.game.getCogThief(cogIndex)
if cogThief.goalId == self.goalId:
pass
result = cogThief.goal == self.goal
return result
def keepDistance(self):
ratio = self.distToNearestFlockmate / self.SeparationDistance
nearestThief = self.game.getCogThief(self.nearestFlockmate)
change = nearestThief.suit.getPos() - self.suit.getPos()
if ratio < self.MinUrgency:
ratio = self.MinUrgency
if ratio > self.MaxUrgency:
ratio = self.MaxUrgency
if self.distToNearestFlockmate < self.SeparationDistance:
change.normalize()
change *= -(1 - ratio)
elif self.distToNearestFlockmate > self.SeparationDistance:
change.normalize()
change *= ratio
else:
change = Vec3(0, 0, 0)
return change
def showKaboom(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.kaboom.reparentTo(render)
self.kaboom.setPos(self.suit.getPos())
self.kaboom.setZ(3)
self.kaboomTrack = Parallel(SoundInterval(self.kaboomSound, volume = 0.5), Sequence(Func(self.kaboom.showThrough), LerpScaleInterval(self.kaboom, duration = 0.5, scale = Point3(10, 10, 10), startScale = Point3(1, 1, 1), blendType = 'easeOut'), Func(self.kaboom.hide)))
self.kaboomTrack.start()
def showSplat(self):
if self.kaboomTrack and self.kaboomTrack.isPlaying():
self.kaboomTrack.finish()
self.splat.reparentTo(render)
self.splat.setPos(self.suit.getPos())
self.splat.setZ(3)
self.kaboomTrack = Parallel(SoundInterval(self.pieHitSound, volume = 1.0), Sequence(Func(self.splat.showThrough), LerpScaleInterval(self.splat, duration = 0.5, scale = 1.75, startScale = Point3(0.10000000000000001, 0.10000000000000001, 0.10000000000000001), blendType = 'easeOut'), Func(self.splat.hide)))
self.kaboomTrack.start()
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.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)
# Cog's Left Arm
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)
# Cog's Right Arm
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.mp3')
self.upSound = globalBattleSoundCache.getSound('AV_jump_to_side.mp3')
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)
