def __initCollisions(self):
collSphere = CollisionSphere(0, 0, 0, Globals.PlayerCollisionRadius)
collSphere.setTangible(0)
self.mazeCollisionName = Globals.LocalPlayerCollisionName
collNode = CollisionNode(self.mazeCollisionName)
collNode.addSolid(collSphere)
collNodePath = self.toon.attachNewNode(collNode)
collNodePath.hide()
handler = CollisionHandlerEvent()
handler.addInPattern('%fn-into-%in')
base.cTrav.addCollider(collNodePath, handler)
self.handler = handler
self._collNodePath = collNodePath
def __initCollisions(self):
collSphere = CollisionSphere(0, 0, 0, Globals.PlayerCollisionRadius)
collSphere.setTangible(0)
self.mazeCollisionName = Globals.LocalPlayerCollisionName
collNode = CollisionNode(self.mazeCollisionName)
collNode.addSolid(collSphere)
collNodePath = self.toon.attachNewNode(collNode)
collNodePath.hide()
handler = CollisionHandlerEvent()
handler.addInPattern('%fn-into-%in')
base.cTrav.addCollider(collNodePath, handler)
self.handler = handler
self._collNodePath = collNodePath
class DistributedIceGame(DistributedMinigame.DistributedMinigame, DistributedIceWorld.DistributedIceWorld):
notify = directNotify.newCategory("DistributedIceGame")
MaxLocalForce = 100
MaxPhysicsForce = 25000
def __init__(self, cr):
DistributedMinigame.DistributedMinigame.__init__(self, cr)
DistributedIceWorld.DistributedIceWorld.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM(
"DistributedIceGame",
[
State.State("off", self.enterOff, self.exitOff, ["inputChoice"]),
State.State(
"inputChoice",
self.enterInputChoice,
self.exitInputChoice,
["waitServerChoices", "moveTires", "displayVotes", "cleanup"],
),
State.State(
"waitServerChoices",
self.enterWaitServerChoices,
self.exitWaitServerChoices,
["moveTires", "cleanup"],
),
State.State("moveTires", self.enterMoveTires, self.exitMoveTires, ["synch", "cleanup"]),
State.State("synch", self.enterSynch, self.exitSynch, ["inputChoice", "scoring", "cleanup"]),
State.State("scoring", self.enterScoring, self.exitScoring, ["cleanup", "finalResults", "inputChoice"]),
State.State("finalResults", self.enterFinalResults, self.exitFinalResults, ["cleanup"]),
State.State("cleanup", self.enterCleanup, self.exitCleanup, []),
],
"off",
"cleanup",
)
self.addChildGameFSM(self.gameFSM)
self.cameraThreeQuarterView = (0, -22, 45, 0, -62.89, 0)
self.tireDict = {}
self.forceArrowDict = {}
self.canDrive = False
self.timer = None
self.timerStartTime = None
self.curForce = 0
self.curHeading = 0
self.headingMomentum = 0.0
self.forceMomentum = 0.0
self.allTireInputs = None
self.curRound = 0
self.curMatch = 0
self.controlKeyWarningLabel = DirectLabel(
text=TTLocalizer.IceGameControlKeyWarning,
text_fg=VBase4(1, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0),
scale=0.15,
)
self.controlKeyWarningLabel.hide()
self.waitingMoveLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075,
)
self.waitingMoveLabel.hide()
self.waitingSyncLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForAISync,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.6, 0, -0.75),
scale=0.075,
)
self.waitingSyncLabel.hide()
self.infoLabel = DirectLabel(text="", text_fg=VBase4(0, 0, 0, 1), relief=None, pos=(0.0, 0, 0.7), scale=0.075)
self.updateInfoLabel()
self.lastForceArrowUpdateTime = 0
self.sendForceArrowUpdateAsap = False
self.treasures = []
self.penalties = []
self.obstacles = []
self.controlKeyPressed = False
self.controlKeyWarningIval = None
return
def delete(self):
DistributedIceWorld.DistributedIceWorld.delete(self)
DistributedMinigame.DistributedMinigame.delete(self)
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningLabel.destroy()
del self.controlKeyWarningLabel
self.waitingMoveLabel.destroy()
del self.waitingMoveLabel
self.waitingSyncLabel.destroy()
del self.waitingSyncLabel
self.infoLabel.destroy()
del self.infoLabel
for treasure in self.treasures:
treasure.destroy()
del self.treasures
for penalty in self.penalties:
penalty.destroy()
del self.penalties
for obstacle in self.obstacles:
obstacle.removeNode()
del self.obstacles
del self.gameFSM
return
def announceGenerate(self):
DistributedMinigame.DistributedMinigame.announceGenerate(self)
DistributedIceWorld.DistributedIceWorld.announceGenerate(self)
self.debugTaskName = self.uniqueName("debugTask")
def getTitle(self):
return TTLocalizer.IceGameTitle
def getInstructions(self):
szId = self.getSafezoneId()
numPenalties = IceGameGlobals.NumPenalties[szId]
result = TTLocalizer.IceGameInstructions
if numPenalties == 0:
result = TTLocalizer.IceGameInstructionsNoTnt
return result
def getMaxDuration(self):
return 0
def load(self):
self.notify.debug("load")
DistributedMinigame.DistributedMinigame.load(self)
self.music = base.loadMusic("phase_4/audio/bgm/MG_IceGame.ogg")
self.gameBoard = loader.loadModel("phase_4/models/minigames/ice_game_icerink")
background = loader.loadModel("phase_4/models/minigames/ice_game_2d")
backgroundWide = loader.loadModel("phase_4/models/minigames/iceslide_ground")
background.reparentTo(self.gameBoard)
backgroundWide.reparentTo(self.gameBoard)
backgroundWide.setPos(0, -0.3, -0.5)
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.setupSimulation()
index = 0
for avId in self.avIdList:
self.setupTire(avId, index)
self.setupForceArrow(avId)
index += 1
for index in xrange(len(self.avIdList), 4):
self.setupTire(-index, index)
self.setupForceArrow(-index)
self.showForceArrows(realPlayersOnly=True)
self.westWallModel = NodePath()
if not self.westWallModel.isEmpty():
self.westWallModel.reparentTo(self.gameBoard)
self.westWallModel.setPos(IceGameGlobals.MinWall[0], IceGameGlobals.MinWall[1], 0)
self.westWallModel.setScale(4)
self.eastWallModel = NodePath()
if not self.eastWallModel.isEmpty():
self.eastWallModel.reparentTo(self.gameBoard)
self.eastWallModel.setPos(IceGameGlobals.MaxWall[0], IceGameGlobals.MaxWall[1], 0)
self.eastWallModel.setScale(4)
self.eastWallModel.setH(180)
self.arrowKeys = ArrowKeys.ArrowKeys()
self.target = loader.loadModel("phase_3/models/misc/sphere")
self.target.setScale(0.01)
self.target.reparentTo(self.gameBoard)
self.target.setPos(0, 0, 0)
self.scoreCircle = loader.loadModel("phase_4/models/minigames/ice_game_score_circle")
self.scoreCircle.setScale(0.01)
self.scoreCircle.reparentTo(self.gameBoard)
self.scoreCircle.setZ(IceGameGlobals.TireRadius / 2.0)
self.scoreCircle.setAlphaScale(0.5)
self.scoreCircle.setTransparency(1)
self.scoreCircle.hide()
self.treasureModel = loader.loadModel("phase_4/models/minigames/ice_game_barrel")
self.penaltyModel = loader.loadModel("phase_4/models/minigames/ice_game_tnt2")
self.penaltyModel.setScale(0.75, 0.75, 0.7)
szId = self.getSafezoneId()
obstacles = IceGameGlobals.Obstacles[szId]
index = 0
cubicObstacle = IceGameGlobals.ObstacleShapes[szId]
for pos in obstacles:
newPos = Point3(pos[0], pos[1], IceGameGlobals.TireRadius)
newObstacle = self.createObstacle(newPos, index, cubicObstacle)
self.obstacles.append(newObstacle)
index += 1
self.countSound = loader.loadSfx("phase_3.5/audio/sfx/tick_counter.ogg")
self.treasureGrabSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_vine_game_bananas.ogg")
self.penaltyGrabSound = loader.loadSfx("phase_4/audio/sfx/MG_cannon_fire_alt.ogg")
self.tireSounds = []
for tireIndex in xrange(4):
tireHit = loader.loadSfx("phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg")
wallHit = loader.loadSfx("phase_4/audio/sfx/MG_maze_pickup.ogg")
obstacleHit = loader.loadSfx("phase_4/audio/sfx/Golf_Hit_Barrier_2.ogg")
self.tireSounds.append({"tireHit": tireHit, "wallHit": wallHit, "obstacleHit": obstacleHit})
self.arrowRotateSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_force_rotate.ogg")
self.arrowUpSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_force_increase_3sec.ogg")
self.arrowDownSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_force_decrease_3sec.ogg")
self.scoreCircleSound = loader.loadSfx("phase_4/audio/sfx/MG_sfx_ice_scoring_1.ogg")
def unload(self):
self.notify.debug("unload")
DistributedMinigame.DistributedMinigame.unload(self)
del self.music
self.gameBoard.removeNode()
del self.gameBoard
for forceArrow in self.forceArrowDict.values():
forceArrow.removeNode()
del self.forceArrowDict
self.scoreCircle.removeNode()
del self.scoreCircle
del self.countSound
def onstage(self):
self.notify.debug("onstage")
DistributedMinigame.DistributedMinigame.onstage(self)
self.gameBoard.reparentTo(render)
self.__placeToon(self.localAvId)
self.moveCameraToTop()
self.scorePanels = []
base.playMusic(self.music, looping=1, volume=0.8)
def offstage(self):
self.notify.debug("offstage")
self.music.stop()
self.gameBoard.hide()
self.infoLabel.hide()
for avId in self.tireDict:
self.tireDict[avId]["tireNodePath"].hide()
for panel in self.scorePanels:
panel.cleanup()
del self.scorePanels
for obstacle in self.obstacles:
obstacle.hide()
for treasure in self.treasures:
treasure.nodePath.hide()
for penalty in self.penalties:
penalty.nodePath.hide()
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.dropShadow.show()
av.resetLOD()
taskMgr.remove(self.uniqueName("aimtask"))
self.arrowKeys.destroy()
del self.arrowKeys
DistributedMinigame.DistributedMinigame.offstage(self)
def handleDisabledAvatar(self, avId):
self.notify.debug("handleDisabledAvatar")
self.notify.debug("avatar " + str(avId) + " disabled")
DistributedMinigame.DistributedMinigame.handleDisabledAvatar(self, avId)
def setGameReady(self):
if not self.hasLocalToon:
return
self.notify.debug("setGameReady")
if DistributedMinigame.DistributedMinigame.setGameReady(self):
return
for index in xrange(self.numPlayers):
avId = self.avIdList[index]
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
self.__placeToon(avId)
toon.forwardSpeed = 0
toon.rotateSpeed = False
toon.dropShadow.hide()
toon.setAnimState("Sit")
if avId in self.tireDict:
tireNp = self.tireDict[avId]["tireNodePath"]
toon.reparentTo(tireNp)
toon.setY(1.0)
toon.setZ(-3)
toon.startLookAround()
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return
self.notify.debug("setGameStart")
DistributedMinigame.DistributedMinigame.setGameStart(self, timestamp)
for avId in self.remoteAvIdList:
toon = self.getAvatar(avId)
if toon:
toon.stopLookAround()
self.scores = [0] * self.numPlayers
spacing = 0.4
for i in xrange(self.numPlayers):
avId = self.avIdList[i]
avName = self.getAvatarName(avId)
scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(avId, avName)
scorePanel.setScale(0.9)
scorePanel.setPos(-0.583 - spacing * (self.numPlayers - 1 - i), 0.0, -0.15)
scorePanel.reparentTo(base.a2dTopRight)
scorePanel.makeTransparent(0.75)
self.scorePanels.append(scorePanel)
self.arrowKeys.setPressHandlers(
[
self.__upArrowPressed,
self.__downArrowPressed,
self.__leftArrowPressed,
self.__rightArrowPressed,
self.__controlPressed,
]
)
def isInPlayState(self):
if not self.gameFSM.getCurrentState():
return False
if not self.gameFSM.getCurrentState().getName() == "play":
return False
return True
def enterOff(self):
self.notify.debug("enterOff")
def exitOff(self):
pass
def enterInputChoice(self):
self.notify.debug("enterInputChoice")
self.forceLocalToonToTire()
self.controlKeyPressed = False
if self.curRound == 0:
self.setupStartOfMatch()
else:
self.notify.debug("self.curRound = %s" % self.curRound)
self.timer = ToontownTimer.ToontownTimer()
self.timer.hide()
if self.timerStartTime != None:
self.startTimer()
self.showForceArrows(realPlayersOnly=True)
self.localForceArrow().setPosHpr(0, 0, -1.0, 0, 0, 0)
self.localForceArrow().reparentTo(self.localTireNp())
self.localForceArrow().setY(IceGameGlobals.TireRadius)
self.localTireNp().headsUp(self.target)
self.notify.debug("self.localForceArrow() heading = %s" % self.localForceArrow().getH())
self.curHeading = self.localTireNp().getH()
self.curForce = 25
self.updateLocalForceArrow()
for avId in self.forceArrowDict:
forceArrow = self.forceArrowDict[avId]
forceArrow.setPosHpr(0, 0, -1.0, 0, 0, 0)
tireNp = self.tireDict[avId]["tireNodePath"]
forceArrow.reparentTo(tireNp)
forceArrow.setY(IceGameGlobals.TireRadius)
tireNp.headsUp(self.target)
self.updateForceArrow(avId, tireNp.getH(), 25)
taskMgr.add(self.__aimTask, self.uniqueName("aimtask"))
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.stop()
self.sendForceArrowUpdateAsap = False
return
def exitInputChoice(self):
if not self.controlKeyPressed:
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningIval = Sequence(
Func(self.controlKeyWarningLabel.show),
self.controlKeyWarningLabel.colorScaleInterval(
10, VBase4(1, 1, 1, 0), startColorScale=VBase4(1, 1, 1, 1)
),
Func(self.controlKeyWarningLabel.hide),
)
self.controlKeyWarningIval.start()
if self.timer != None:
self.timer.destroy()
self.timer = None
self.timerStartTime = None
self.hideForceArrows()
self.arrowRotateSound.stop()
self.arrowUpSound.stop()
self.arrowDownSound.stop()
taskMgr.remove(self.uniqueName("aimtask"))
return
def enterWaitServerChoices(self):
self.waitingMoveLabel.show()
self.showForceArrows(True)
def exitWaitServerChoices(self):
self.waitingMoveLabel.hide()
self.hideForceArrows()
def enterMoveTires(self):
for key in self.tireDict:
body = self.tireDict[key]["tireBody"]
body.setAngularVel(0, 0, 0)
body.setLinearVel(0, 0, 0)
for index in xrange(len(self.allTireInputs)):
input = self.allTireInputs[index]
avId = self.avIdList[index]
body = self.getTireBody(avId)
degs = input[1] + 90
tireNp = self.getTireNp(avId)
tireH = tireNp.getH()
self.notify.debug("tireH = %s" % tireH)
radAngle = deg2Rad(degs)
foo = NodePath("foo")
dirVector = Vec3(math.cos(radAngle), math.sin(radAngle), 0)
self.notify.debug("dirVector is now=%s" % dirVector)
inputForce = input[0]
inputForce /= self.MaxLocalForce
inputForce *= self.MaxPhysicsForce
force = dirVector * inputForce
self.notify.debug("adding force %s to %d" % (force, avId))
body.addForce(force)
self.enableAllTireBodies()
self.totalPhysicsSteps = 0
self.startSim()
taskMgr.add(self.__moveTiresTask, self.uniqueName("moveTiresTtask"))
def exitMoveTires(self):
self.forceLocalToonToTire()
self.disableAllTireBodies()
self.stopSim()
self.notify.debug("total Physics steps = %d" % self.totalPhysicsSteps)
taskMgr.remove(self.uniqueName("moveTiresTtask"))
def enterSynch(self):
self.waitingSyncLabel.show()
def exitSynch(self):
self.waitingSyncLabel.hide()
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug("newScores = %s" % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug("circleStartTime = %s" % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time, Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound, duration=time, startTime=circleStartTime),
)
)
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug("for avId %d, startScore=%d, newScores=%d" % (avId, startScore, destScore))
def increaseScores(t, scorePanelIndex=scorePanelIndex, startScore=startScore, destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore - startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]["tireNodePath"]
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0, VBase4(1, 1, 1, 1)),
),
)
)
curScale += distance
self.scoreMovie.append(Func(self.sendUpdate, "reportScoringMovieDone", []))
self.scoreMovie.start()
def exitScoring(self):
self.scoreMovie.finish()
self.scoreMovie = None
self.scoreCircle.hide()
return
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.6
bY = -0.05
lX = -0.5
cX = 0
rX = 0.5
scorePanelLocs = (
((cX, bY),),
((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)),
((lX, tY), (rX, tY), (lX, bY), (rX, bY)),
)
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
panel.wrtReparentTo(aspect2d)
lerpTrack.append(
Parallel(
LerpPosInterval(panel, lerpDur, Point3(pos[0], 0, pos[1]), blendType="easeInOut"),
LerpScaleInterval(panel, lerpDur, Vec3(panel.getScale()) * 2.0, blendType="easeInOut"),
)
)
self.showScoreTrack = Parallel(
lerpTrack, Sequence(Wait(IceGameGlobals.ShowScoresDuration), Func(self.gameOver))
)
self.showScoreTrack.start()
def exitFinalResults(self):
self.showScoreTrack.pause()
del self.showScoreTrack
def enterCleanup(self):
self.notify.debug("enterCleanup")
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.start()
def exitCleanup(self):
pass
def __placeToon(self, avId):
toon = self.getAvatar(avId)
if toon:
toon.setPos(0, 0, 0)
toon.setHpr(0, 0, 0)
def moveCameraToTop(self):
camera.reparentTo(render)
p = self.cameraThreeQuarterView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
def setupTire(self, avId, index):
tireNp, tireBody, tireOdeGeom = self.createTire(index)
self.tireDict[avId] = {"tireNodePath": tireNp, "tireBody": tireBody, "tireOdeGeom": tireOdeGeom}
if avId <= 0:
tireBlocker = tireNp.find("**/tireblockermesh")
if not tireBlocker.isEmpty():
tireBlocker.hide()
if avId == self.localAvId:
tireNp = self.tireDict[avId]["tireNodePath"]
self.treasureSphereName = "treasureCollider"
self.treasureCollSphere = CollisionSphere(0, 0, 0, IceGameGlobals.TireRadius)
self.treasureCollSphere.setTangible(0)
self.treasureCollNode = CollisionNode(self.treasureSphereName)
self.treasureCollNode.setFromCollideMask(ToontownGlobals.PieBitmask)
self.treasureCollNode.addSolid(self.treasureCollSphere)
self.treasureCollNodePath = tireNp.attachNewNode(self.treasureCollNode)
self.treasureHandler = CollisionHandlerEvent()
self.treasureHandler.addInPattern("%fn-intoTreasure")
base.cTrav.addCollider(self.treasureCollNodePath, self.treasureHandler)
eventName = "%s-intoTreasure" % self.treasureCollNodePath.getName()
self.notify.debug("eventName = %s" % eventName)
self.accept(eventName, self.toonHitSomething)
def setupForceArrow(self, avId):
arrow = loader.loadModel("phase_4/models/minigames/ice_game_arrow")
priority = 0
if avId < 0:
priority = -avId
else:
priority = self.avIdList.index(avId)
if avId == self.localAvId:
priority = 10
self.forceArrowDict[avId] = arrow
def hideForceArrows(self):
for forceArrow in self.forceArrowDict.values():
forceArrow.hide()
def showForceArrows(self, realPlayersOnly=True):
for avId in self.forceArrowDict:
if realPlayersOnly:
if avId > 0:
self.forceArrowDict[avId].show()
else:
self.forceArrowDict[avId].hide()
else:
self.forceArrowDict[avId].show()
def localForceArrow(self):
if self.localAvId in self.forceArrowDict:
return self.forceArrowDict[self.localAvId]
else:
return None
return None
def setChoices(self, input0, input1, input2, input3):
pass
def startDebugTask(self):
taskMgr.add(self.debugTask, self.debugTaskName)
def stopDebugTask(self):
taskMgr.remove(self.debugTaskName)
def debugTask(self, task):
if self.canDrive and self.tireDict.has_key(localAvatar.doId):
dt = globalClock.getDt()
forceMove = 25000
forceMoveDt = forceMove
tireBody = self.tireDict[localAvatar.doId]["tireBody"]
if self.arrowKeys.upPressed() and not tireBody.isEnabled():
x = 0
y = 1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.downPressed() and not tireBody.isEnabled():
x = 0
y = -1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.leftPressed() and not tireBody.isEnabled():
x = -1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.rightPressed() and not tireBody.isEnabled():
x = 1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
return task.cont
def __upArrowPressed(self):
pass
def __downArrowPressed(self):
pass
def __leftArrowPressed(self):
pass
def __rightArrowPressed(self):
pass
def __controlPressed(self):
if self.gameFSM.getCurrentState().getName() == "inputChoice":
self.sendForceArrowUpdateAsap = True
self.updateLocalForceArrow()
self.controlKeyPressed = True
self.sendUpdate("setAvatarChoice", [self.curForce, self.curHeading])
self.gameFSM.request("waitServerChoices")
def startTimer(self):
now = globalClock.getFrameTime()
elapsed = now - self.timerStartTime
self.timer.posInTopRightCorner()
self.timer.setTime(IceGameGlobals.InputTimeout)
self.timer.countdown(IceGameGlobals.InputTimeout - elapsed, self.handleChoiceTimeout)
self.timer.show()
def setTimerStartTime(self, timestamp):
if not self.hasLocalToon:
return
self.timerStartTime = globalClockDelta.networkToLocalTime(timestamp)
if self.timer != None:
self.startTimer()
return
def handleChoiceTimeout(self):
self.sendUpdate("setAvatarChoice", [0, 0])
self.gameFSM.request("waitServerChoices")
def localTireNp(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]["tireNodePath"]
return ret
def localTireBody(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]["tireBody"]
return ret
def getTireBody(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]["tireBody"]
return ret
def getTireNp(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]["tireNodePath"]
return ret
def updateForceArrow(self, avId, curHeading, curForce):
forceArrow = self.forceArrowDict[avId]
tireNp = self.tireDict[avId]["tireNodePath"]
tireNp.setH(curHeading)
tireBody = self.tireDict[avId]["tireBody"]
tireBody.setQuaternion(tireNp.getQuat())
self.notify.debug("curHeading = %s" % curHeading)
yScale = curForce / 100.0
yScale *= 1
headY = yScale * 15
xScale = (yScale - 1) / 2.0 + 1.0
shaft = forceArrow.find("**/arrow_shaft")
head = forceArrow.find("**/arrow_head")
shaft.setScale(xScale, yScale, 1)
head.setPos(0, headY, 0)
head.setScale(xScale, xScale, 1)
def updateLocalForceArrow(self):
avId = self.localAvId
self.b_setForceArrowInfo(avId, self.curHeading, self.curForce)
def __aimTask(self, task):
if not hasattr(self, "arrowKeys"):
return task.done
dt = globalClock.getDt()
headingMomentumChange = dt * 60.0
forceMomentumChange = dt * 160.0
arrowUpdate = False
arrowRotating = False
arrowUp = False
arrowDown = False
if self.arrowKeys.upPressed() and not self.arrowKeys.downPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce += self.forceMomentum * dt
arrowUpdate = True
if oldForce < self.MaxLocalForce:
arrowUp = True
elif self.arrowKeys.downPressed() and not self.arrowKeys.upPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce -= self.forceMomentum * dt
arrowUpdate = True
if oldForce > 0.01:
arrowDown = True
else:
self.forceMomentum = 0
if self.arrowKeys.leftPressed() and not self.arrowKeys.rightPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading += self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
elif self.arrowKeys.rightPressed() and not self.arrowKeys.leftPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading -= self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
else:
self.headingMomentum = 0
if arrowUpdate:
self.normalizeHeadingAndForce()
self.updateLocalForceArrow()
if arrowRotating:
if not self.arrowRotateSound.status() == self.arrowRotateSound.PLAYING:
base.playSfx(self.arrowRotateSound, looping=True)
else:
self.arrowRotateSound.stop()
if arrowUp:
if not self.arrowUpSound.status() == self.arrowUpSound.PLAYING:
base.playSfx(self.arrowUpSound, looping=False)
else:
self.arrowUpSound.stop()
if arrowDown:
if not self.arrowDownSound.status() == self.arrowDownSound.PLAYING:
base.playSfx(self.arrowDownSound, looping=False)
else:
self.arrowDownSound.stop()
return task.cont
def normalizeHeadingAndForce(self):
if self.curForce > self.MaxLocalForce:
self.curForce = self.MaxLocalForce
if self.curForce < 0.01:
self.curForce = 0.01
def setTireInputs(self, tireInputs):
if not self.hasLocalToon:
return
self.allTireInputs = tireInputs
self.gameFSM.request("moveTires")
def enableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]["tireBody"].enable()
def disableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]["tireBody"].disable()
def areAllTiresDisabled(self):
for avId in self.tireDict.keys():
if self.tireDict[avId]["tireBody"].isEnabled():
return False
return True
def __moveTiresTask(self, task):
if self.areAllTiresDisabled():
self.sendTirePositions()
self.gameFSM.request("synch")
return task.done
return task.cont
def sendTirePositions(self):
tirePositions = []
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
self.sendUpdate("endingPositions", [tirePositions])
def setFinalPositions(self, finalPos):
if not self.hasLocalToon:
return
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
def updateInfoLabel(self):
self.infoLabel["text"] = TTLocalizer.IceGameInfo % {
"curMatch": self.curMatch + 1,
"numMatch": IceGameGlobals.NumMatches,
"curRound": self.curRound + 1,
"numRound": IceGameGlobals.NumRounds,
}
def setMatchAndRound(self, match, round):
if not self.hasLocalToon:
return
self.curMatch = match
self.curRound = round
self.updateInfoLabel()
def setScores(self, match, round, scores):
if not self.hasLocalToon:
return
self.newMatch = match
self.newRound = round
self.newScores = scores
def setNewState(self, state):
if not self.hasLocalToon:
return
self.notify.debug("setNewState gameFSM=%s newState=%s" % (self.gameFSM, state))
self.gameFSM.request(state)
def putAllTiresInStartingPositions(self):
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
np = self.tireDict[avId]["tireNodePath"]
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug("avId=%s newPos=%s" % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]["tireBody"]
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
for index in xrange(len(self.avIdList), 4):
avId = -index
np = self.tireDict[avId]["tireNodePath"]
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug("avId=%s newPos=%s" % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]["tireBody"]
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
def b_setForceArrowInfo(self, avId, force, heading):
self.setForceArrowInfo(avId, force, heading)
self.d_setForceArrowInfo(avId, force, heading)
def d_setForceArrowInfo(self, avId, force, heading):
sendIt = False
curTime = self.getCurrentGameTime()
if self.sendForceArrowUpdateAsap:
sendIt = True
elif curTime - self.lastForceArrowUpdateTime > 0.2:
sendIt = True
if sendIt:
self.sendUpdate("setForceArrowInfo", [avId, force, heading])
self.sendForceArrowUpdateAsap = False
self.lastForceArrowUpdateTime = self.getCurrentGameTime()
def setForceArrowInfo(self, avId, force, heading):
if not self.hasLocalToon:
return
self.updateForceArrow(avId, force, heading)
def setupStartOfMatch(self):
self.putAllTiresInStartingPositions()
szId = self.getSafezoneId()
self.numTreasures = IceGameGlobals.NumTreasures[szId]
if self.treasures:
for treasure in self.treasures:
treasure.destroy()
self.treasures = []
index = 0
treasureMargin = IceGameGlobals.TireRadius + 1.0
while len(self.treasures) < self.numTreasures:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5, IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5, IceGameGlobals.MaxWall[1] - 5)
self.notify.debug("yPos=%s" % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newTreasure = IceTreasure.IceTreasure(self.treasureModel, pos, index, self.doId, penalty=False)
goodSpot = True
for obstacle in self.obstacles:
if newTreasure.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
if goodSpot:
for treasure in self.treasures:
if newTreasure.nodePath.getDistance(treasure.nodePath) < treasureMargin:
goodSpot = False
break
if goodSpot:
self.treasures.append(newTreasure)
index += 1
else:
newTreasure.destroy()
self.numPenalties = IceGameGlobals.NumPenalties[szId]
if self.penalties:
for penalty in self.penalties:
penalty.destroy()
self.penalties = []
index = 0
while len(self.penalties) < self.numPenalties:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5, IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5, IceGameGlobals.MaxWall[1] - 5)
self.notify.debug("yPos=%s" % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newPenalty = IceTreasure.IceTreasure(self.penaltyModel, pos, index, self.doId, penalty=True)
goodSpot = True
for obstacle in self.obstacles:
if newPenalty.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
if goodSpot:
for treasure in self.treasures:
if newPenalty.nodePath.getDistance(treasure.nodePath) < treasureMargin:
goodSpot = False
break
if goodSpot:
for penalty in self.penalties:
if newPenalty.nodePath.getDistance(penalty.nodePath) < treasureMargin:
goodSpot = False
break
if goodSpot:
self.penalties.append(newPenalty)
index += 1
else:
newPenalty.destroy()
def toonHitSomething(self, entry):
self.notify.debug("---- treasure Enter ---- ")
self.notify.debug("%s" % entry)
name = entry.getIntoNodePath().getName()
parts = name.split("-")
if len(parts) < 3:
self.notify.debug("collided with %s, but returning" % name)
return
if not int(parts[1]) == self.doId:
self.notify.debug("collided with %s, but doId doesn't match" % name)
return
treasureNum = int(parts[2])
if "penalty" in parts[0]:
self.__penaltyGrabbed(treasureNum)
else:
self.__treasureGrabbed(treasureNum)
def __treasureGrabbed(self, treasureNum):
self.treasures[treasureNum].showGrab()
self.treasureGrabSound.play()
self.sendUpdate("claimTreasure", [treasureNum])
def setTreasureGrabbed(self, avId, treasureNum):
if not self.hasLocalToon:
return
self.notify.debug("treasure %s grabbed by %s" % (treasureNum, avId))
if avId != self.localAvId:
self.treasures[treasureNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] += 1
self.scorePanels[i].setScore(self.scores[i])
def __penaltyGrabbed(self, penaltyNum):
self.penalties[penaltyNum].showGrab()
self.sendUpdate("claimPenalty", [penaltyNum])
def setPenaltyGrabbed(self, avId, penaltyNum):
if not self.hasLocalToon:
return
self.notify.debug("penalty %s grabbed by %s" % (penaltyNum, avId))
if avId != self.localAvId:
self.penalties[penaltyNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] -= 1
self.scorePanels[i].setScore(self.scores[i])
def postStep(self):
DistributedIceWorld.DistributedIceWorld.postStep(self)
if not self.colCount:
return
for count in xrange(self.colCount):
c0, c1 = self.getOrderedContacts(count)
if c1 in self.tireCollideIds:
tireIndex = self.tireCollideIds.index(c1)
if c0 in self.tireCollideIds:
self.tireSounds[tireIndex]["tireHit"].play()
elif c0 == self.wallCollideId:
self.tireSounds[tireIndex]["wallHit"].play()
elif c0 == self.obstacleCollideId:
self.tireSounds[tireIndex]["obstacleHit"].play()
def forceLocalToonToTire(self):
toon = localAvatar
if toon and self.localAvId in self.tireDict:
tireNp = self.tireDict[self.localAvId]["tireNodePath"]
toon.reparentTo(tireNp)
toon.setPosHpr(0, 0, 0, 0, 0, 0)
toon.setY(1.0)
toon.setZ(-3)
snipstuff.info_message("You clicked '%s'!"%pickingEnabledOject.getName())
if status == 'up':
pickingEnabledOject.setScale(1.0)
#** This is a task function called each frame, where the collision ray position is syncronized with the mouse pointer position
def rayupdate(task):
if base.mouseWatcherNode.hasMouse():
mpos=base.mouseWatcherNode.getMouse()
# this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position, making magically hit what is pointed by it in the 3d space
pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
#** Now the tricky part: we have here a particular kind of pattern that react firing a task event when a collider, tagged as 'rays', whatever the value is stored into, hit an object tagged as 'balls', no matter what value is stored into its tag. The resulting event strings sent to the panda3D event manager will be the result of the FROM collider (ray) and the tag value owned by the INTO object being hit (a ball), provided that was settled with a tag key 'balls'.
# That said, these two lines will catch all the events for either smiles and frowneys because we both tagged 'em as 'balls', for all IN events...
collisionHandler.addInPattern("%(rays)ft-into-%(balls)it")
# ...and here for the OUT events
collisionHandler.addOutPattern("%(rays)ft-out-%(balls)it")
#** To complicate things a little, this time we'll going to use the addAgainPattern method, that will raise an event while the mouse ponter is keeping over a ball of any group. Note that the 'ray_again_all' chunk will be used by the CollisionHandlerEvent to fire the event. See the related accept below.
collisionHandler.addAgainPattern(
"ray_again_all%(""rays"")fh%(""balls"")ih"
)
""" Note that we could have been done the same using this form as well:
collisionHandler.addAgainPattern("%(rays)ft-again-%(balls)it")
but then we should have used 2 accepts like this:
DO.accept('ray1-again-smileys', collideAgainBalls)
DO.accept('ray1-again-frowney', collideAgainBalls)
class CogdoFlyingCollisions(GravityWalker):
wantFloorSphere = 0
def __init__(self):
GravityWalker.__init__(self, gravity=0.0)
def initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius = 1.4, floorOffset = 1.0, reach = 1.0):
self.cHeadSphereNodePath = None
self.cFloorEventSphereNodePath = None
self.setupHeadSphere(avatarNodePath)
self.setupFloorEventSphere(avatarNodePath, ToontownGlobals.FloorEventBitmask, avatarRadius)
GravityWalker.initializeCollisions(self, collisionTraverser, avatarNodePath, avatarRadius, floorOffset, reach)
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75, self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def deleteCollisions(self):
GravityWalker.deleteCollisions(self)
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
self.cHeadSphereNodePath.detachNode()
self.cHeadSphereNodePath = None
self.headCollisionsEvent = None
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
self.cFloorEventSphereNodePath.detachNode()
self.cFloorEventSphereNodePath = None
self.floorCollisionEvent = None
self.cRayNodePath.detachNode()
del self.cRayNodePath
self.cEventSphereNodePath.detachNode()
del self.cEventSphereNodePath
def setCollisionsActive(self, active = 1):
if self.collisionsActive != active:
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
if active:
base.cTrav.addCollider(self.cHeadSphereNodePath, self.headCollisionEvent)
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
if active:
base.cTrav.addCollider(self.cFloorEventSphereNodePath, self.floorCollisionEvent)
GravityWalker.setCollisionsActive(self, active)
def enableAvatarControls(self):
pass
def disableAvatarControls(self):
pass
def handleAvatarControls(self, task):
pass
class StrategyGame(ShowBase):
def __init__(self):
ShowBase.__init__(self)
self.camera_control()
self.REGION_MAP = "maps/italy_provs.png"
self.TEXTURE_MAP = "maps/italy_terrain2.png"
self.WORLD_MAP = "maps/italy_map.xml"
self.SCENARIO_MAP = "scenarios/italy_scen.xml"
self.terrainScale = 1 # Currently Broken
self.keyboard_setup()
self.drawTerrain()
self.xml_load_map(self.WORLD_MAP,"WorldMap")
self.xml_load_map(self.SCENARIO_MAP,"Scenario")
self.init_collisions()
self.pickingEnabledObject = None
self.taskMgr.add(self.camera_update, "UpdateCameraTask")
self.generate_models()
self.txtBox = OnscreenText("<No province>")
self.setup_collision_calcs()
taskMgr.add(self.rayUpdate, "updatePicker")
taskMgr.doMethodLater(0.2,self.task_calendar, "calendar")
self.init_variables()
self.interface()
def init_variables(self):
self.armies = [[],[]]
for n in range(len(self.nations)):
self.armies.append(n)
self.target = 0
self.army_count = 0
self.selected_prov = -1
self.months = ["January","February","March","April","May","June",
"July","August","September","October","November","December"]
self.adce = "AD"
self.player = 1
self.money_inc = 0
for p in range(len(self.provs)):
if self.provs_owner[p] == self.player:
self.money_inc += self.provs_money[p]
self.men_inc = 0
for p in range(len(self.provs)):
if self.provs_owner[p] == self.player:
self.men_inc += self.provs_men[p]
def draw_card(self,x,y,width,height,colour):
cm = CardMaker("CardMaker")
cm.setFrame(x, x+width,y+height, y)
card = render2d.attachNewNode(cm.generate())
card.setColor(colour)
return (card)
def interface(self):
self.interface_back = self.draw_card(-0.8,-1,1.6,0.4,(100,100,100,100))
self.txt_name = OnscreenText(text = "", pos = (-0.8,-0.7,-0.8))
self.txt_money = OnscreenText(text = "", pos = (-0.8,-0.8,-0.8))
self.txt_men = OnscreenText(text = "", pos = (-0.8,-0.9,-0.8))
self.txt_nation = OnscreenText(text = self.nations[self.player-1], pos = (-1.2,0.9,-0.8))
self.txt_nation_money = OnscreenText(text = "Coin: " + str(self.nations_money[self.player-1])+" +"+str(self.money_inc), pos = (-0.4,0.9,-0.8))
self.txt_nation_men = OnscreenText(text = "Manpower: " + str(self.nations_men[self.player-1])+" +"+str(self.men_inc), pos = (0.4,0.9,-0.8))
self.txt_date = OnscreenText(text = str(self.day)+" of "+self.months[self.month-1]+" "+str(self.year)+self.adce, pos = (-1.0,0.8,-0.8))
def task_calendar(self,task):
#task.delayTime = 5
if (self.month == 1 or self.month == 3 or self.month == 5 or
self.month == 7 or self.month == 8 or self.month == 10 or self.month == 12):
if self.day == 31 and self.month == 12:
self.day = 1
self.month = 1
self.year += 1
elif self.day == 31:
self.day = 1
self.month += 1
else:
self.day += 1
elif (self.month == 4 or self.month == 6 or self.month == 9 or self.month == 11):
if self.day == 30:
self.day = 1
self.month += 1
else:
self.day += 1
elif (self.month == 2):
# if isleap:
# print self.year/4
# print "LEAP YEAR"
# if self.day == 29:
# self.day = 1
# self.month = 3
# else:
# self.day += 1
# else:
print "IS NOT A LEAP YEAR"
if self.day == 28:
self.day = 1
self.month = 3
else:
self.day += 1
self.daypass()
return Task.again
def daypass(self):
self.nations_money[self.player-1] += self.money_inc
self.nations_men[self.player-1] += self.men_inc
self.update_interface()
def update_interface(self):
self.txt_date.setText(str(self.day)+" of "+self.months[self.month-1]+" "+str(self.year)+self.adce)
self.txt_nation_money.setText("Coin: " + str(self.nations_money[self.player-1])+" +"+str(self.money_inc))
self.txt_nation_men.setText("Manpower: " + str(self.nations_men[self.player-1])+" +"+str(self.men_inc))
if self.selected_prov != -1:
self.txt_name.setText("Province: "+self.provs[self.selected_prov])
self.txt_money.setText("Income: "+str(self.provs_money[self.selected_prov]))
self.txt_men.setText("Manpower: "+str(self.provs_men[self.selected_prov]))
self.interface_back.setColor(self.format_colour_tuple(self.nations_rgb[self.provs_owner[self.selected_prov]-1]))
else:
self.txt_name.setText("")
self.txt_money.setText("")
self.txt_men.setText("")
self.interface_back.setColor((255,255,255,255))
def army_create(self):
id = self.army_count+1
army = self.loader.loadModel("models/man.x")
self.armies[0].append(id)
army.reparentTo(self.render)
army.setName(str(id))
army.setScale(1, 1, 1)
x = 50
y = 50
target = self.target
target_x = float(self.provs_x[target])
target_y = 257-float(self.provs_y[target])
target_z = float(self.getObjectZ(target_x,target_y)-1)
oArmyCol = army.attachNewNode(CollisionNode("BuildingCNode%d"%id))
oArmyCol.setScale((2,2,2))
oArmyCol.node().addSolid(CollisionSphere(0,0,0,1))
oArmyCol.setTag("unit","army")
oArmyCol.show()
point1 = Point3(x,y,0)
point2 = Point3(target_x,target_y,target_z)
distance = (point1.getXy() - point2.getXy()).length()
myInterval = army.posInterval(distance/10, Point3(target_x,target_y, target_z))
mySequence = Sequence(myInterval)
mySequence.start()
army.setPos(x, y, self.getObjectZ(x,y)-1)
army.setTag("target",str(target))
self.army_count += 1
if (self.target<len(self.provs)-1):
self.target += 1
else:
self.target = 0
#taskMgr.add()
def army_update(self,id):
point1 = self.armies[0][id-1].getPos()
point2 = Point3(target_x,target_y,target_z)
distance = (point1.getXy() - point2.getXy()).length()
def init_collisions(self):
base.cTrav = CollisionTraverser()
self.cHandler = CollisionHandlerEvent()
pickerNode = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(pickerNode)
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
pickerNode.setTag("rays","ray1")
base.cTrav.addCollider(pickerNPos, self.cHandler)
def setup_collision_calcs(self):
self.cHandler.addInPattern("%(rays)ft-into-%(prov)it")
self.cHandler.addOutPattern("%(rays)ft-out-%(prov)it")
self.cHandler.addAgainPattern("ray_again_all%(""rays"")fh%(""prov"")ih")
self.DO=DirectObject()
self.DO.accept('ray1-into-city', self.collideInBuilding)
self.DO.accept('ray1-out-city', self.collideOutBuilding)
self.DO.accept('ray_again_all', self.collideAgainstBuilds)
self.pickingEnabledOject=None
self.DO.accept('mouse1', self.mouseClick, ["down"])
self.DO.accept('mouse1-up', self.mouseClick, ["up"])
def camera_control(self):
base.disableMouse()
self.camera = base.camera
self.cam_speed = 3
self.cam_drag = 0.01
self.cam_x_moving = False
self.cam_y_moving = False
self.cam_z_moving = False
self.cam_x_inc = 0
self.cam_y_inc = 0
self.cam_z_inc = 0
self.cameraDistance = -50
self.camHeight = 25
self.camXAngle = 0
self.camYAngle = -25
self.camZAngle = 0
self.camX = 0
self.camY = 0
self.camZ = 100
def camera_update(self,task):
if self.cam_x_moving:
self.camX+=self.cam_x_inc
elif self.cam_x_inc != 0:
if (self.cam_x_inc > 0 and self.cam_x_inc-self.cam_drag <= 0) or (self.cam_x_inc < 0 and self.cam_x_inc+self.cam_drag >= 0):
self.cam_x_inc = 0
elif self.cam_x_inc > 0:
self.cam_x_inc -= self.cam_drag
elif self.cam_x_inc < 0:
self.cam_x_inc -= self.cam_drag
else:
print "FUCKUP WITH CAM X INC"
if self.cam_y_moving:
self.camY+=self.cam_y_inc
elif self.cam_y_inc != 0:
if (self.cam_y_inc > 0 and self.cam_y_inc-self.cam_drag <= 0) or (self.cam_y_inc < 0 and self.cam_y_inc+self.cam_drag >= 0):
self.cam_y_inc = 0
elif self.cam_y_inc > 0:
self.cam_y_inc -= self.cam_drag
elif self.cam_y_inc < 0:
self.cam_y_inc -= self.cam_drag
else:
print "FUCKUP WITH CAM Y INC"
if self.cam_z_moving:
self.camZ+=self.cam_z_inc
elif self.cam_z_inc != 0:
if (self.cam_z_inc > 0 and self.cam_z_inc-self.cam_drag <= 0) or (self.cam_z_inc < 0 and self.cam_z_inc+self.cam_drag >= 0):
self.cam_z_inc = 0
elif self.cam_z_inc > 0:
self.cam_z_inc -= self.cam_drag
elif self.cam_z_inc < 0:
self.cam_z_inc -= self.cam_drag
else:
print "FUCKUP WITH CAM Z INC"
self.camera.setPos(self.camX, self.camY, self.camZ)
self.camera.setHpr(self.camXAngle, self.camYAngle, self.camZAngle)
return Task.cont
def camera_move(self, status):
if status == "up":
self.cam_y_moving = True
self.cam_y_inc = self.cam_speed
if status == "down":
self.cam_y_moving = True
self.cam_y_inc = -self.cam_speed
if status == "left":
self.cam_x_moving = True
self.cam_x_inc = -self.cam_speed
if status == "right":
self.cam_x_moving = True
self.cam_x_inc = self.cam_speed
if status == "stopX":
self.cam_x_moving = False
if status == "stopY":
self.cam_y_moving = False
def keyboard_setup(self):
self.accept("w", self.keyW)
self.accept("w-up", self.stop_y)
self.accept("s", self.keyS)
self.accept("s-up", self.stop_y)
self.accept("a", self.keyA)
self.accept("a-up", self.stop_x)
self.accept("d", self.keyD)
self.accept("d-up", self.stop_x)
self.accept("+", self.ZoomIn)
self.accept("c", self.createArmy)
def createArmy(self):
self.army_create()
def ZoomIn(self):
self.camZ -= 1
def keyW( self ):
self.camera_move("up")
def keyS( self ):
self.camera_move("down")
def keyA( self ):
self.camera_move("left")
def keyD( self ):
self.camera_move("right")
def stop_x( self ):
self.camera_move("stopX")
def stop_y( self ):
self.camera_move("stopY")
def generate_models(self):
for p in range(len(self.provs)):
print "Making",self.provs[p]
city = self.loader.loadModel("models/house2.x")
city.reparentTo(self.render)
city.setName(self.provs[p])
city.setScale(2, 2, 2)
x = float(self.provs_x[p]*self.terrainScale)
y = 257*self.terrainScale-float(self.provs_y[p]*self.terrainScale)
city.setPos(x, y, self.getObjectZ(x,y)-1)
oCityCol = city.attachNewNode(CollisionNode("BuildingCNode%d"%p))
oCityCol.setScale((3,3,3))
oCityCol.node().addSolid(CollisionSphere(0,0,0,1))
oCityCol.setTag("prov","city")
city.setTag("id",str(p+1))
#oCityCol.show()
def collideInBuilding(self,entry):
np_into=entry.getIntoNodePath()
np_into.getParent().setColor(.6,.5,1.0,1)
def collideOutBuilding(self,entry):
np_into=entry.getIntoNodePath()
np_into.getParent().setColor(1.0,1.0,1.0,1)
self.pickingEnabledObject = None
self.txtBox.setText("<No province>")
def collideAgainstBuilds(self,entry):
if entry.getIntoNodePath().getParent() <> self.pickingEnabledOject:
np_from=entry.getFromNodePath()
np_into=entry.getIntoNodePath()
self.pickingEnabledObject = np_into.getParent()
self.txtBox.setText(self.pickingEnabledObject.getName())
def mouseClick(self,status):
if self.pickingEnabledObject:
if status == "down":
self.pickingEnabledObject.setScale(0.95*2)
print self.pickingEnabledObject.getTag("id"),self.provs[int(self.pickingEnabledObject.getTag("id"))-1]
self.selected_prov = int(self.pickingEnabledObject.getTag("id"))-1
self.update_interface()
if status == "up":
self.pickingEnabledObject.setScale(1.0*2)
elif self.pickingEnabledObject == None:
self.selected_prov = -1
self.update_interface()
def rayUpdate(self,task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def getObjectZ(self, x, y):
if ((x > 0) and (x < 257) and (y > 0) and (y < 257)):
return(self.terrain.getElevation(x,y)*self.terrainSize)
else:
return 0
def format_colour_tuple(self,colour):
col = string.split(colour)
tuple = (int(col[0]),int(col[1]),int(col[2]),255)
return tuple
def drawTerrain(self):
self.terrainSize = 5
heightmap = "maps/italy_heightmap.png"
colmap = self.TEXTURE_MAP
self.terrain = GeoMipTerrain("terrain")
self.terrain.setHeightfield(heightmap)
self.terrain.setColorMap(colmap)
self.terrain.setBlockSize(64)
#self.terrain.setNear(40)
#self.terrain.setFar(120)
#self.terrain.setMinLevel(1)
self.terrain.setBruteforce(True)
self.terrain.generate()
self.terrain.setAutoFlatten(self.terrain.AFMLight)
self.root = self.terrain.getRoot()
self.root.reparentTo(render)
self.root.setSz(self.terrainSize)
#self.root.setScale(self.terrainScale,self.terrainScale,1)
def xml_load_map(self,file,type):
if type == "WorldMap":
tree = xml.parse(file)
root = tree.getroot()
self.provs = []
self.provs_x = []
self.provs_y = []
self.provs_rgb = []
self.provs_owner = []
self.provs_money = []
self.provs_men = []
counter = 1
for p in root.findall("province"):
self.provs.append(self.get_tag(root,"province", counter, "name"))
self.provs_x.append(self.get_tag(root, "province", counter, "x"))
self.provs_y.append(self.get_tag(root, "province", counter, "y"))
self.provs_rgb.append(self.get_tag(root, "province", counter, "rgb"))
self.provs_owner.append(0)
self.provs_money.append(0)
self.provs_men.append(0)
counter+=1
elif type == "Scenario":
tree = xml.parse(file)
root = tree.getroot()
self.day = 0
self.month = 0
self.year = 0
self.adce = 0
self.day = int(root.attrib["day"])
self.month = int(root.attrib["month"])
self.year = int(root.attrib["year"])
self.nations = []
self.nations_rgb = []
self.nations_capital = []
self.nations_money = []
self.nations_men = []
self.nations_provs_id = []
counter = 0
for p in root.findall("province"):
print p.attrib["id"]
for n in root.findall("nation"):
for p in n.findall("province"):
self.provs_owner[int(p.attrib["id"])-1] = int(p.find("owner").text)
self.provs_money[int(p.attrib["id"])-1] = int(p.find("money").text)
self.provs_men[int(p.attrib["id"])-1] = int(p.find("men").text)
print self.provs_owner[int(p.attrib["id"])-1]
counter+=1
counter = 1
for n in root.findall("nation"):
self.nations.append(self.get_tag(root, "nation", counter, "name"))
self.nations_capital.append(n.attrib["capital"])
#print self.nations_capital
self.nations_rgb.append(self.get_tag(root, "nation", counter, "rgb"))
self.nations_money.append(int(self.get_tag(root, "nation", counter, "money")))
self.nations_men.append(int(self.get_tag(root, "nation", counter, "men")))
counter += 1
def get_tag(self,root,str_tag,prov_id, prov_tag):
prov = root.find('.//'+str_tag+'[@id="'+str(prov_id)+'"]')
tag = prov.find(prov_tag).text
return tag
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay
from pandaImports import DirectObject
from tower import *
"""This file handles all the collision events
of our game
"""
# base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav = CollisionTraverser()
# collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
# "In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern("%fn-into-%in")
# "Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern("%fn-again-%in")
# "Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern("%fn-out-%in")
# self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0, 0, 0]
# self.addCollider(mousePicking.pickerNP)
# self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]):
class Coin:
"""
An object that a ball collects.
"""
MODEL = "../egg/kolikko.egg"
collectable = 0
def __init__(self, model, world, space, pos):
self.model = model
self.world = world
self.space = space
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.addBox(pos)
self.isCollected = False
Coin.collectable += 1
def collect(self):
if not self.isCollected:
self.isCollected = True
self.box.setColor(1, 0, 0)
Coin.collectable -= 1
def onCollide(self, entry):
body1 = entry.getFromNodePath()
ballNode = self.model.getBall().getModelNode()
if ballNode and ballNode == body1.getParent():
self.collect()
def addBox(self, pos):
lx, ly, lz = 1, 1, 1 # dimension
px, py, pz = pos # position
name = "box" + str(pos)
self.box = loader.loadModel(self.MODEL)
self.box.setPos(-0.5, -0.5, -0.5)
self.box.flattenLight() # ApplyTransform
self.box.reparentTo(render)
# Make sure its center is at 0, 0, 0 like OdeBoxGeom
self.box.setPos(px - lx / 2, py - ly / 2, pz - lz / 2)
self.box.setScale(lx, ly, lz)
self.box.setHpr(0, 50, 0)
# Offset z by -1.0 because the coin model was so small
cSphere = CollisionSphere(pos[0], pos[1], pos[2] - 1.0, 1)
cNode = CollisionNode(name)
cNode.addSolid(cSphere)
model = render.find(name)
if not model.isEmpty():
model.removeNode()
cnodePath = render.attachNewNode(cNode)
#cnodePath.show()
base.cTrav.addCollider(cnodePath, self.collHandEvent)
base.accept('into-' + name, self.onCollide)
# Implementation below would not allow coins to float?
# define mass
"""
mass = OdeMass()
mass.setBox(500, lx, ly, lz)
self.boxBody = OdeBody( self.world )
self.boxBody.setPosition( self.box.getPos(render) )
self.boxBody.setQuaternion( self.box.getQuat(render) )
self.boxBody.setMass( mass )
self.geom = OdeBoxGeom( self.space, lx, ly, lz)
self.space.setSurfaceType( self.geom, SurfaceType.COIN )
self.geom.setBody( self.boxBody )
self.boxBody = None
"""
def updateModelNode(self):
return None
#None
#self.box.setPos( render, self.boxBody.getPosition() )
#self.box.setQuat(render, Quat(self.boxBody.getQuaternion() ) )
def getBody(self):
return None
#return self.boxBody
def removeNode(self):
if not self.isCollected:
Coin.collectable -= 1
# http://www.panda3d.org/apiref.php?page=NodePath#removeNode
self.box.removeNode()
class Game(DirectObject.DirectObject):
def __init__(self, showbase, usersData, gameData):
self.showbase = showbase
self.usersData = usersData
self.gameData = gameData
random.seed(self.gameData.randSeed)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.world = World(showbase)
for user in self.usersData:
user.centipede = Centipede(showbase, len(self.usersData), self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
self.ticks = 0
def destroy(self):
self.world.destroy()
for user in self.usersData:
user.centipede.destroy()
for food in self.foods:
food.destroy()
def runTick(self, dt):
# run each of the centipedes simulations
for user in self.usersData:
user.centipede.update(dt)
if len(user.centipede.body) > 10:
return False
for food in self.foods:
food.update(dt)
self.cTrav.traverse(self.showbase.render)
self.ticks += 1
# Return true if game is still not over (false to end game)
return True
def collideInto(self, collEntry):
for user in self.usersData:
if collEntry.getFromNodePath() == user.centipede.head.collisionNode[0]:
for food in self.foods:
if collEntry.getIntoNodePath() == food.model.collisionNode[0]:
user.centipede.addLength(self.showbase)
food.reset()
if len(user.centipede.body) > 2:
if collEntry.getIntoNodePath() == user.centipede.tail.collisionNode[0]:
user.centipede.reset()
for i in range(len(user.centipede.body) - 1 - 2):
if collEntry.getIntoNodePath() == user.centipede.body[i + 2].collisionNode[0]:
user.centipede.reset()
break
def addToCollisions(self, item):
# Add this object to the traverser.
self.cTrav.addCollider(item[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept('into-' + str(item[1]), self.collideInto)
snipstuff.info_show()
base.disableMouse()
# =========================================================================
# Main
"""
While the principles are almost the same for 3D space, picking in 2D require a little change to adapt to the 2D layer, it's aspect and camera view (that is called orthographic).
"""
# =========================================================================
# ** First big difference: as you may know, we used so far to assign the collision traverser to the global Showbase member cTrav, that is automatically updated (traversed) but it operates under the render nodepath that we know works in the 3D space and thewrefore we'll store the traverser apart in a convenient variable to be manually traversed later by our routine and act in 2d space.
customCtrav = CollisionTraverser()
collisionHandler = CollisionHandlerEvent()
# to keep the stuff simple, we specify fixed pattern strings to just check the into and out of all our colliders, because we know they are just cards and the ray FROM collider
collisionHandler.addInPattern("ray-into-cards")
collisionHandler.addOutPattern("ray-out-cards")
PICKING_MASK = BitMask32.bit(1)
# ** Setting the ray collider
pickerNode = CollisionNode("mouseraycnode")
# another important but obvious difference from step 6 is that this time we parent the ray nodepath in render2d instead render root nodepath, otherwise all the objects we're going to define in 2D won't be seen by the ray.
pickerNP = base.render2d.attachNewNode(pickerNode)
pickerNP.show()
# note that this time we set the ray dimension along the Y axis 2 point long to pierce everything is on the Y=0 position (2D objects are usually placed there)
pickerRay = CollisionRay(0, -1, 0, 0, 1, 0)
pickerNode.addSolid(pickerRay)
pickerNode.setFromCollideMask(PICKING_MASK)
pickerNode.setIntoCollideMask(BitMask32.allOff())
# ** put the ray into the traverse cycle
class Level2World(object):
def __init__(self, render, loader, theBase, world, hopper):
self.render = render
self.loader = loader
base = theBase
self.world = world
self.hopper = hopper
base.disableMouse()
#----- Play Music -----
self.backgroundMusic = base.loader.loadSfx("sounds/deathDanceMusic.mp3")
self.backgroundMusic.play()
self.failSound = base.loader.loadSfx("sounds/fail.wav")
#------ State Variables -----
self.isLit = False
#----- Setup Visible World -----
self.platforms = []
self.spinningPlatforms = []
self.spinners = []
self.berries = []
self.coins = []
self.enemies = []
self.setupPlatforms()
self.setupCoins()
self.setupBerries()
self.setupEnemies()
self.endToken = Coin(self.render, self.world, self.hopper, 0, 0.6, 0.6, Vec3(0, 0, 1))
self.endToken.coinNP.reparentTo(self.platforms[-1].platformBulletNode)
self.wizardLair = WizardLair(self.render, self.world, self.loader, self.hopper)
self.wizardLair.wizardGate.reparentTo(self.platforms[1].platformBulletNode)
self.wizardLair.castle.reparentTo(self.platforms[6].platformBulletNode)
self.wizardLair.lair.reparentTo(self.platforms[11].platformBulletNode)
self.sky = loader.loadModel("models/art/cat-skies/alice-skies--celestial/celestial.egg")
self.sky.setPos(0, 0, 0)
self.sky.setP(90)
self.sky.setScale(1)
self.sky.reparentTo(self.render)
#----- Setup Light -----
self.directionalLight2 = DirectionalLight( "directionalLight" )
self.directionalLight2.setColor( Vec4( 1, 1, 1, 1 ) )
self.directionalLight2.setDirection(Vec3(0, 0, -1))
self.directionalLightNP = self.render.attachNewNode(self.directionalLight2)
#----- Collision Handling -----
base.cTrav = CollisionTraverser()
self.collisionHandler = CollisionHandlerEvent()
self.pickerNode = CollisionNode('mouseRayCollisionNode')
self.pickerNP = base.camera.attachNewNode(self.pickerNode)
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(self.pickerNP, self.collisionHandler)
self.collisionHandler.addInPattern("mouseRayIntoEnemy")
self.collisionHandler.addOutPattern("mouseRayOutEnemy")
self.pickingEnabledObject = None
#----- Tasks -----
def update(self, task):
self.hopper.processInput()
for enemy in self.enemies:
if enemy.getHealth() != 0: enemy.pace()
dt = globalClock.getDt()
self.world.doPhysics(dt, 10, 1/180.0)
return task.cont
def simulateWater(self, task):
if self.hopper.hopperNP.getZ() < 0:
self.hopper.freeze = True
return task.done
else:
return task.cont
def rayUpdate(self, task):
if base.mouseWatcherNode.hasMouse():
mPos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mPos.getX(), mPos.getY())
return task.cont
#----- Setup Enemy Functions -----
def setupEnemies(self):
enemy1 = Enemy(self.render, self.world, base, Point3(0, 0, 1), self.hopper, 1)
enemy1.enemyNP.reparentTo(self.platforms[3].platformBulletNode)
enemy2 = Enemy(self.render, self.world, base, Point3(0, 0, 1), self.hopper, 2)
enemy2.enemyNP.reparentTo(self.platforms[4].platformBulletNode)
self.enemies.append(enemy1)
self.enemies.append(enemy2)
#----- Lair Enemies -----
enemy = Enemy(self.render, self.world, base, Point3(3, 16, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
enemy = Enemy(self.render, self.world, base, Point3(3, -16, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
enemy = Enemy(self.render, self.world, base, Point3(13, 3, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
enemy = Enemy(self.render, self.world, base, Point3(-13, 3, 1), self.hopper, 1, strength = 2, size = 1.3)
enemy.enemyNP.reparentTo(self.platforms[11].platformBulletNode)
self.enemies.append(enemy)
def resetEnemies(self):
for enemy in self.enemies:
enemy.enemyNP.remove_node()
self.enemies = []
self.setupEnemies()
def collideEventIn(self, entry):
print "Selected enemy!"
np_from = entry.getFromNodePath()
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(.6, 0.5, 1.0, 1)
self.pickingEnabledObject = np_into
def collideEventOut(self, entry):
print "Deselected enemy!"
self.pickingEnabledObject = None
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(1.0, 1.0, 1.0, 1)
def mousePick(self, status):
if self.pickingEnabledObject:
if status == 'down':
idNum = self.pickingEnabledObject.getTag("id")
self.enemies[int(idNum)-1].lowerHealth()
if status == 'up':
pass
#----- Setup Item Functions -----
def setupPlatforms(self):
path = "images/wizardFloor.jpg"
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-2, 3, -1), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-13, 3, -1), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-24, 3, 0), roll = 20, tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-38, 3, 3), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-50, 3, 4), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(10, 7, 0.5), Point3(-62, 3, 5), tex = path)
self.platforms.append(platform)
platform = Platform(self.render, self.world, 0, Vec3(30, 30, 0.5), Point3(-72, 3, 6), tex = path)
self.platforms.append(platform)
x = -68; y = 3; z = 5
heading = 0
for i in range(4):
platform = Platform(self.render, self.world, heading, Vec3(7, 6, 0.5), Point3(x, y, z), tex = path)
self.platforms.append(platform)
self.spinningPlatforms.append(platform)
x -= 8; z += 1.8
platform = Platform(self.render, self.world, 0, Vec3(30, 30, 0.5), Point3(x - 40, -15, z), tex = path)
self.platforms.append(platform)
x -= 40; y = 3
heading = 45
for i in range(4):
platform = Platform(self.render, self.world, heading, Vec3(9, 7, 0.5), Point3(x, y, z), tex = path)
self.platforms.append(platform)
if i == 0 or i == 2:
spinner = Spinner(self.render, self.world, 90, 25, Vec3(2.2, 0.3, 1), Point3(x+9, y+7, z+2))
self.spinners.append(spinner)
x -= 10; y -= 10; z += 1.8
def setupCoins(self):
#----- Castle Coins -----
x = 3
for i in range(9):
coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(x, -8, 2))
coin.coinNP.reparentTo(self.platforms[6].platformBulletNode)
self.coins.append(coin)
x -= 2
#----- Lair Coins -----
x = 3
for i in range(8):
coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(x, -12, 2))
coin.coinNP.reparentTo(self.platforms[11].platformBulletNode)
self.coins.append(coin)
x -= 2
index = 2
for i in range(4):
coin = Coin(self.render, self.world, self.hopper, 10, 0.35, 0.35, Point3(0, 0, 2))
coin.coinNP.reparentTo(self.platforms[index].platformBulletNode)
self.coins.append(coin)
index += 4
def resetCoins(self):
print "Inside coins; NOT removing a coin but initializing list to 0"
self.coins = []
self.setupCoins()
def setupBerries(self):
index = 3
mult = 1
for i in range(4):
berry1 = Berry(self.render, self.world, self.hopper, 10*mult, 0.35, 0.35, Point3(0, 0, 2))
berry1.berryNP.reparentTo(self.platforms[index].platformBulletNode)
self.berries.append(berry1)
index += 3
mult *= -1
if mult > 0:
mult *= 2
else:
mult /= 2
def resetBerries(self):
self.berries = []
self.setupBerries()
#----- Light Functions -----
def addLight(self):
self.dlight = DirectionalLight('dlight')
self.dlight.setColor(VBase4(0.9, 0.9, 0.8, 1))
self.dlnp = self.render.attachNewNode(self.dlight)
self.dlnp.setHpr(90, -30, 0)
self.render.setLight(self.dlnp)
self.slight = Spotlight('slight')
slens = PerspectiveLens()
self.slight.setLens(slens)
self.slight.setColor(Vec4(1, 1, 1, 1))
self.slnp = self.render.attachNewNode(self.slight)
self.slnp.reparentTo(self.hopper.hopperNP)
self.slnp.setPos(0, 40, 50)
self.slnp.lookAt(self.hopper.hopperNP)
self.render.setLight(self.slnp)
self.alight = AmbientLight('alight')
self.alight.setColor(VBase4(0.2, 0.4, 1, 1))
self.alnp = self.render.attachNewNode(self.alight)
self.render.setLight(self.alnp)
self.render.setShaderAuto()
self.slight.setShadowCaster(True)
for platform in self.platforms:
platform.removeNormal()
def destroyLight(self):
self.render.clearLight(self.dlnp)
self.render.clearLight(self.alnp)
self.render.clearLight(self.slnp)
for platform in self.platforms:
platform.addNormal()
def destroyWorld(self):
for platform in self.platforms:
self.world.removeRigidBody(platform.platformBulletNode.node())
platform.platformBulletNode.remove_node()
for spinner in self.spinners:
self.world.removeRigidBody(spinner.spinnerBulletNode.node())
spinner.spinnerBulletNode.remove_node()
for coin in self.coins:
self.world.removeGhost(coin.ghostNode)
coin.removeCoin()
for enemy in self.enemies:
enemy.enemyNP.remove_node()
snipstuff.info_show()
base.disableMouse()
#=========================================================================
# Main
"""
While the principles are almost the same for 3D space, picking in 2D require a little change to adapt to the 2D layer, it's aspect and camera view (that is called orthographic).
"""
#=========================================================================
#** First big difference: as you may know, we used so far to assign the collision traverser to the global Showbase member cTrav, that is automatically updated (traversed) but it operates under the render nodepath that we know works in the 3D space and thewrefore we'll store the traverser apart in a convenient variable to be manually traversed later by our routine and act in 2d space.
customCtrav = CollisionTraverser()
collisionHandler = CollisionHandlerEvent()
# to keep the stuff simple, we specify fixed pattern strings to just check the into and out of all our colliders, because we know they are just cards and the ray FROM collider
collisionHandler.addInPattern("ray-into-cards")
collisionHandler.addOutPattern("ray-out-cards")
PICKING_MASK = BitMask32.bit(1)
#** Setting the ray collider
pickerNode = CollisionNode('mouseraycnode')
# another important but obvious difference from step 6 is that this time we parent the ray nodepath in render2d instead render root nodepath, otherwise all the objects we're going to define in 2D won't be seen by the ray.
pickerNP = base.render2d.attachNewNode(pickerNode)
pickerNP.show()
# note that this time we set the ray dimension along the Y axis 2 point long to pierce everything is on the Y=0 position (2D objects are usually placed there)
pickerRay = CollisionRay(0, -1, 0, 0, 1, 0)
pickerNode.addSolid(pickerRay)
pickerNode.setFromCollideMask(PICKING_MASK)
pickerNode.setIntoCollideMask(BitMask32.allOff())
#** put the ray into the traverse cycle
class MyApp(ShowBase):
def cleanUpStartScreen( self ):
self.startButton.destroy( ) # get rid of the button
self.logoModel.detachNode( ) # detach the logo model from the render
self.loadGame( ) # load the actual game
# end cleanUpStartScreen
def addInstructions(pos, msg):
return OnscreenText(text=msg, style=1, fg=(1,1,1,1),pos=(-1.3, pos), align=TextNode.ALeft, scale = .05)
def __init__(self):
global x,y,z
#self.loadStartScreen()
ShowBase.__init__(self)
#self.setupBackgroundColor(1,1,1)
# set the camera position
#camera.setPosHpr( Vec3( 0, -10, 0 ), Vec3( 0, 0, 0 ) )
# load our logo model
self.logoModel = loader.loadModel("bvw-f2004--truck/cartruck.egg")
self.logoModel.reparentTo( render )
# set the logo model's position
self.logoModel.setPosHpr( Vec3( 0, 15, 0 ), Vec3( 0, 0, 0 ) )
# create and display a start button
self.startButton = DirectButton( text = "Go!", relief = DGG.RAISED, scale = .1, pad = ( .5, .5 ), pos = Vec3( 1.0, 0.0, -0.8 ), command = self.cleanUpStartScreen )
self.disableMouse()
self.obs = [None] * 100
self.keyMap = {"forward":0, "slow":0, "left":0, "right":0}
#self.environ = [None]*100
self.grb= [None] * 100
self.env= [None] * 20
self.env1= [None] * 20
self.envx= [None] * 20
self.envy= [None] * 20
self.title = OnscreenText(text="SCORE: " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95,0.85), scale = .07, mayChange = True)
self.title1 = OnscreenText(text="LIVES: " + str(int (gameover/2)), style=1, fg=(1,1,0,1), pos=(-0.95,0.7), scale = .07, mayChange = True)
self.timeleft = OnscreenText(text="TIME LEFT: " + str(int(time/60)) + " : " + str(int(time%60)), style=1, fg=(1,1,0,1), pos=(-0.95,0.55), scale = .07, mayChange = True)
self.model= self.loader.loadModel("alice-farm--cornfield/cornfield.egg")
self.model.reparentTo(self.render)
self.model.setPos(-8, 42, 0)
self.model.setScale(20,1000,20)
# Reparent the model to render.
self.environ2 = self.loader.loadModel("bvw-f2004--building/building.egg")
self.environ2.reparentTo(self.render)
self.environ2.setPos(S1x, S1y, S1z)
self.environ2.setScale(0.2, 0.2, 0.2)
for i in range(0,100):
self.obs[i]= self.loader.loadModel("alice-objects--anvil/anvil.egg")
self.obs[i].reparentTo(self.render)
self.obs[i].setX(random.choice([0, 10]))
self.obs[i].setY(random.randint(100,100000))
self.obs[i].setZ(3)
self.obs[i].setScale(10,20,10)
for j in range(0,100):
self.grb[j]= self.loader.loadModel("alice-shapes--icosahedron/icosahedron.egg")
self.grb[j].reparentTo(self.render)
self.grb[j].setX(random.choice([0, 10]))
self.grb[j].setY(random.randint(100, 100000))
self.grb[j].setZ(3)
self.grb[j].setScale(0.8,3,0.8)
for k in range(0,20):
self.envx[k]= self.loader.loadModel("bvw-f2004--building/building.egg")
self.envx[k].reparentTo(self.render)
self.envx[k].setX(random.choice([-60, 60]))
self.envx[k].setY(random.randint(13000, 35000))
self.envx[k].setZ(0)
self.envx[k].setScale(0.8, 0.8, 0.8)
for k in range(0,20):
self.envy[k]= self.loader.loadModel("bvw-f2004--russianbuilding/tetris-building.egg")
self.envy[k].reparentTo(self.render)
self.envy[k].setX(random.choice([-100, 100]))
self.envy[k].setY(random.randint(38000, 60000))
self.envy[k].setZ(0)
self.envy[k].setScale(0.8, 0.8, 0.8)
self.environ4 = self.loader.loadModel("alice-city--townhouse1/townhouse1.egg")
self.environ4.reparentTo(self.render)
self.environ4.setPos(T1x, T1y, T1z)
self.environ4.setScale(0.6, 0.6, 0.6)
self.BS = self.loader.loadModel("alice-skies--bluesky/bluesky.egg")
self.BS.reparentTo(self.render)
self.BS.setScale(10,10,10)
self.BS.setPos(-180,0,0)
self.barn= self.loader.loadModel("alice-farm--farmhouse/farmhouse.egg")
self.barn.reparentTo(self.render)
self.barn.setScale(0.5, 0.5, 0.5)
self.barn.setPos(30,500,0)
self.barn1= self.loader.loadModel("alice-beach--beachhouse2/beachhouse2.egg")
self.barn1.reparentTo(self.render)
self.barn1.setScale(0.5, 0.5, 0.5)
self.barn1.setPos(40,200,0)
self.barn2= self.loader.loadModel("alice-beach--beachhouse2/beachhouse2.egg")
self.barn2.reparentTo(self.render)
self.barn2.setScale(0.5,0.5,0.5)
self.barn2.setPos(70,1700,0)
self.barn3= self.loader.loadModel("bvw-f2004--russianbuilding/tetris-building.egg")
self.barn3.reparentTo(self.render)
self.barn3.setScale(0.5,0.5,0.5)
self.barn3.setPos(-90,1500,0)
self.barn5= self.loader.loadModel("bvw-f2004--course1/course1.egg")
self.barn5.reparentTo(self.render)
self.barn5.setScale(0.25, 0.25, 0.25)
self.barn5.setPos(-100,900,0)
# Apply scale and position transforms on the model.
self.environ1= self.loader.loadModel("alice-vehicles--zamboni/zamboni.egg")
self.environ1.reparentTo(self.render)
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.environ1.setScale(0.3, 0.3, 0.3)
print E1posY
def loadGame(self):
self.camera.setPos(CposX, CposY, CposZ)
self.camera.setHpr(0,0,0)
#for j in range(0, 100):
#self.environ[j] = self.loader.loadModel("CityTerrain/CityTerrain")
#self.environ[j].reparentTo(self.render)
#self.environ[j].setPos(-8,42 + 210*j,0)
#self.environ[j].setScale(0.25,0.25,0.25)
self.accept("arrow_up-repeat", self.setKey, ["forward", 1])
self.accept("arrow_down-repeat", self.setKey, ["slow", 1])
self.accept("arrow_left", self.setKey, ["left", 1])
self.accept("arrow_right", self.setKey, ["right", 1])
base.cTrav = CollisionTraverser()
self.collHandEvent = CollisionHandlerEvent()
self.collCount=0
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
sColl = self.initCollisionSphere(self.environ1, True)
base.cTrav.addCollider(sColl[0], self.collHandEvent)
for child in render.getChildren():
if child != camera and child != self.environ2 and child!= self.environ4 and child != self.BS and child!= self.model and child!= self.barn and child!= self.barn1 and child!= self.barn2 and child!= self.barn3 and child!= self.barn5:
#print child
tColl = self.initCollisionSphere(child, True)
base.cTrav.addCollider(tColl[0], self.collHandEvent)
self.accept('into-' + tColl[1] , self.collide)
## for m in range(0,100):
## tgrb= self.initCollisionSphere(self.grb[i], True)
## base.cTrav.addCollider(tgrb[0], self.collHandEvent)
## self.accept('into-' + tgrb[1], self.collide)
##
## for n in range(0,100):
## tobs= self.initCollisionSphere(self.obs[i], True)
## base.cTrav.addCollider(tobs[0], self.collHandEvent)
## self.accept('into-' + tobs[1], self.collide)
self.taskMgr.add(self.move, "moveTask")
def initCollisionSphere(self, obj,show=False):
# Get the size of the object for the collision sphere.
bounds = obj.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius() *0.5
# Create a collison sphere
collSphereStr = 'CollisionHull' + str(self.collCount) + "_" + obj.getName()
self.collCount += 1
cNode = CollisionNode(collSphereStr)
cNode.addSolid(CollisionSphere(center, radius))
cNodepath = obj.attachNewNode(cNode)
#cNodepath.show()
# Return a tuple with the collision node and its corrsponding string so
# that the bitmask can be set.
return (cNodepath, collSphereStr)
def collide(self, collEntry):
global score,E1posY,gameover,adj, CposY
if self.environ1.getY()==-100:
return
if(collEntry.getIntoNodePath().getParent().getName()== "icosahedron.egg"):
#print collEntry.getIntoNodePath().getParent().getName()
collEntry.getIntoNodePath().getParent().remove()
score= score +10
print score
self.title.detachNode()
self.title = OnscreenText(text="SCORE: " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95,0.85), scale = .07, mayChange = True)
elif(collEntry.getIntoNodePath().getParent().getName()== "anvil.egg"):
E1posY= E1posY-50
CposY= CposY-50
self.camera.setPos(CposX, CposY, CposZ)
self.environ1.setPos(E1posX, E1posY, E1posZ)
gameover= gameover - 1
self.title1.detachNode()
self.title1= OnscreenText(text="LIVES: " + str(int(gameover/2)), style=1, fg=(1,1,0,1), pos=(-0.95, 0.7), scale = .07, mayChange = True)
print gameover
if(gameover<=0):
print "Game Over"
## time2= int(time-(task.time*0.5))
## if time1!=time2:
## self.inst2.detachNode()
## self.inst2 = addInstructions(0.89, "Time: "+str(time2))
## time1=time2
## if time2==0:
OnscreenText(text= "GAME OVER", style=1, fg=(1,1,1,1),pos=(-0.9,0), align=TextNode.ALeft, scale = 0.35)
OnscreenText(text= "Your Final Score is " + str(score), style=1, fg=(1,1,0,1), pos=(-0.95, -0.05), align=TextNode.ALeft, scale=0.015)
#time.sleep(10)
#sys.exit
self.environ1.detachNode()
self.camera.detachNode()
def setKey(self, key, value):
self.keyMap[key]= value
def move(self, task):
global E1posX, E1posY, E1posY, CposX, CposY, CposZ, S1y, S2y, T1y, n, y,speed, time
self.over=0
ts= int(task.time)
time= 120 -ts
print time,ts
self.timeleft.detachNode()
self.timeleft= OnscreenText(text="TIME LEFT: " + str(int(time/60)) + " : " + str(int(time%60)), style=1, fg=(1,1,0,1), pos=(-0.95,0.55), scale = .07, mayChange = True)
if(time<=0):
time=0
OnscreenText(text= "GAME OVER", style=1, fg=(1,1,1,1),pos=(-0.9,0), align=TextNode.ALeft, scale = 0.35)
OnscreenText(text= "Your Final Score is " + str(score), style=1,fg=(1,1,0,1), pos=(-0.95, -0.05), align=TextNode.ALeft, scale=0.02)
#time.sleep(10)
#sys.exit
self.environ1.detachNode()
self.over=1
if(self.keyMap["forward"]==1):
self.keyMap["forward"]=0
speed= 10
if speed>=10:
speed= 20
elif speed>=20:
speed= 30
dist= speed
print dist
E1posY= E1posY + dist
CposY= CposY + dist
S1y= S1y + dist
S2y= S2y + dist
T1y= T1y + dist
y= y+ dist
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
if(E1posY==7500 * n or E1posY== 7500 *n +20):
n= n+1
self.environ4.setPos(T1x, T1y, T1z)
#self.environ3.setPos(S2x, S2y, S2z)
self.environ2.setPos(S1x, S1y, S1z)
self.model.setPos(x,y + 550,z)
print E1posX, E1posY, E1posZ, CposX, CposY, CposZ, x, y, z
elif(self.keyMap["slow"]==1):
global slowadj
self.keyMap["slow"]=0
if slowadj<100:
slowadj+= slowadj
speed= speed-10
if speed<0:
speed=0
elif slowadj<200:
slowadj+= slowadj
speed= speed-10
if speed<0:
speed=0
elif slowadj<300:
slowadj+= slowadj
speed= speed-10
if speed<0:
speed=0
elif slowadj>=300:
speed=0
print speed
E1posY= E1posY + speed
CposY= CposY + speed
S1y= S1y + speed
S2y= S2y + speed
T1y= T1y + speed
y= y + speed
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
if(E1posY>=7700 * n and E1posY<= 7700 *n + 30):
n= n+1
self.environ4.setPos(T1x, T1y, T1z)
self.environ3.setPos(S2x, S2y, S2z)
self.environ2.setPos(S1x, S1y, S1z)
self.model.setPos(x,y + 550,z)
print E1posX, E1posY, E1posZ, CposX, CposY, CposZ
elif(self.keyMap["left"]==1):
self.keyMap["left"]=0
if(E1posX!=0):
E1posX=0
CposX=0
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
elif(self.keyMap["right"]==1):
self.keyMap["right"]=0
if(E1posX!=10):
E1posX=10
CposX=10
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
elif(self.keyMap["forward"]==0):
if(self.over==1):
CposY= CposY
elif(self.over==0):
print E1posY, CposY, speed
E1posY= E1posY + speed
CposY= CposY + speed
S1y= S1y + speed
S2y= S2y + speed
T1y= T1y + speed
y= y + speed
self.environ1.setPos(E1posX, E1posY, E1posZ)
self.camera.setPos(CposX, CposY, CposZ)
if(E1posY>=7500 * n and E1posY<= 7500 *n + 30):
n= n+1
self.environ4.setPos(T1x, T1y, T1z)
#self.environ3.setPos(S2x, S2y, S2z)
self.environ2.setPos(S1x, S1y, S1z)
self.model.setPos(x,y + 550,z)
return Task.cont
if status == 'up':
pickingEnabledOject.setScale(1.0)
#** This is a task function called each frame, where the collision ray position is syncronized with the mouse pointer position
def rayupdate(task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
# this function will set our ray to shoot from the actual camera lenses off the 3d scene, passing by the mouse pointer position, making magically hit what is pointed by it in the 3d space
pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
#** Now the tricky part: we have here a particular kind of pattern that react firing a task event when a collider, tagged as 'rays', whatever the value is stored into, hit an object tagged as 'balls', no matter what value is stored into its tag. The resulting event strings sent to the panda3D event manager will be the result of the FROM collider (ray) and the tag value owned by the INTO object being hit (a ball), provided that was settled with a tag key 'balls'.
# That said, these two lines will catch all the events for either smiles and frowneys because we both tagged 'em as 'balls', for all IN events...
collisionHandler.addInPattern("%(rays)ft-into-%(balls)it")
# ...and here for the OUT events
collisionHandler.addOutPattern("%(rays)ft-out-%(balls)it")
#** To complicate things a little, this time we'll going to use the addAgainPattern method, that will raise an event while the mouse ponter is keeping over a ball of any group. Note that the 'ray_again_all' chunk will be used by the CollisionHandlerEvent to fire the event. See the related accept below.
collisionHandler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"balls"
")ih")
""" Note that we could have been done the same using this form as well:
collisionHandler.addAgainPattern("%(rays)ft-again-%(balls)it")
but then we should have used 2 accepts like this:
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
global carx, cary, d, cor_ans, count
self.disableMouse()
self.Truck = [0] * 6
self.crate = [0] * 10
self.posc = [0] * 30
self.radX = [0] * 60
self.radY = [0] * 60
self.radZ = [0] * 60
self.sX = [0] * 10
self.sY = [0] * 10
self.sZ = [0] * 10
self.flag = [0] * 10
self.ans = [0] * 10
self.inst1 = addInstructions(0.89, "Correct Answer: " + str(cor_ans))
self.inst2 = addInstructions(0.95, "Time: " + str(time))
self.inst3 = addInstructions(0.84,
"Waste Reamaining " + str(count / 2))
#self.title = addTitle("Recycle Game By : Sandeep Sharma")
p = 0
file = open("ans.txt")
for line in file:
#for p in range(30):
#print line
line = line.split()
self.ans[p] = str(line[0])
p = p + 1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
p = 0
file = open("sample.txt")
for line in file:
#for p in range(30):
line = line[0:len(line) - 1]
#print line
self.posc[p] = int(line)
p = p + 1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
p = 0
file = open("scale.txt")
for line in file:
#for p in range(30):
line = line.split()
#print line
self.sX[p] = float(line[0])
self.sY[p] = float(line[1])
self.sZ[p] = float(line[2])
#print self.radY[p]
p = p + 1
p = 0
file = open("rad.txt")
for line in file:
#for p in range(30):
line = line.split()
#print line
self.radX[p] = float(line[0])
self.radY[p] = float(line[1])
self.radZ[p] = float(line[2])
#print self.radY[p]
p = p + 1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
self.CornField = self.loader.loadModel("cornfield")
self.CornField.reparentTo(self.render)
self.CornField.setScale(1000, 1000, 0)
self.CornField.setPos(0, 0, -8)
self.WM = self.loader.loadModel("WM/Windmill")
self.WM.reparentTo(self.render)
self.WM.setScale(2, 2, 2)
self.WM.setPos(354, 131, 0)
self.WM.setHpr(180, 0, 0)
self.F1 = self.loader.loadModel("Forest/Forest")
self.F1.reparentTo(self.render)
self.F1.setScale(0.8, 0.5, 0.5)
self.F1.setPos(-338, -164, 0)
self.F1.setHpr(90, 0, 0)
self.F2 = self.loader.loadModel("Forest/Forest")
self.F2.reparentTo(self.render)
self.F2.setScale(0.8, 0.5, 0.5)
self.F2.setPos(366, -189, 0)
self.F2.setHpr(90, 0, 0)
self.castle = self.loader.loadModel("castle")
self.castle.reparentTo(self.render)
self.castle.setScale(0.6, 0.8, 0.5)
self.castle.setPos(-97, -200, 0)
self.castle.setHpr(90, 0, 0)
#print self.castle
self.church = self.loader.loadModel("church/Church")
self.church.reparentTo(self.render)
self.church.setScale(2.5, 2.5, 1)
self.church.setPos(90, -200, 0)
self.church.setHpr(180, 0, 0)
self.Temple = self.loader.loadModel("Temple/TempleFort")
self.Temple.reparentTo(self.render)
self.Temple.setScale(0.06, 0.1, 0.18)
self.Temple.setPos(210, -109, 0)
self.house = self.loader.loadModel("BuildingCluster3")
self.house.reparentTo(self.render)
self.house.setScale(1.5, 1.5, 1)
self.house.setPos(208, 86, 0)
self.CityHall = self.loader.loadModel("cityhall/CityHall")
self.CityHall.reparentTo(self.render)
self.CityHall.setScale(1.5, 1.5, 1.5)
self.CityHall.setPos(-188, -84, 0)
self.CityHall.setHpr(90, 0, 0)
self.statue = self.loader.loadModel("statue/statue")
self.statue.reparentTo(self.render)
self.statue.setScale(4.5, 4.5, 3.5)
self.statue.setPos(-191, 105, 0)
self.statue.setHpr(-90, 0, 0)
self.FarmHouse = self.loader.loadModel("farmhouse/FarmHouse")
self.FarmHouse.reparentTo(self.render)
self.FarmHouse.setScale(2.8, 3.5, 2.5)
self.FarmHouse.setPos(-66, 209, 0)
self.Fence1 = self.loader.loadModel("fence/fence")
self.Fence1.reparentTo(self.render)
self.Fence1.setScale(70, 1, 2)
self.Fence1.setPos(0, -418, 0)
self.Fence2 = self.loader.loadModel("fence/fence")
self.Fence2.reparentTo(self.render)
self.Fence2.setScale(70, 1, 2)
self.Fence2.setPos(0, 418, 0)
self.Fence3 = self.loader.loadModel("fence/fence")
self.Fence3.reparentTo(self.render)
self.Fence3.setScale(70, 1, 2)
self.Fence3.setPos(-418, 0, 0)
self.Fence3.setHpr(90, 0, 0)
self.Fence4 = self.loader.loadModel("fence/fence")
self.Fence4.reparentTo(self.render)
self.Fence4.setScale(70, 1, 2)
self.Fence4.setPos(418, 0, 0)
self.Fence4.setHpr(90, 0, 0)
self.CityTerrain = self.loader.loadModel("CityTerrain/CityTerrain")
self.CityTerrain.reparentTo(self.render)
self.CityTerrain.setScale(0.5, 0.5, 0.5)
self.CityTerrain.setPos(0, 0, 0)
self.BeachTerrain = self.loader.loadModel("BeachTerrain/BeachTerrain")
self.BeachTerrain.reparentTo(self.render)
self.BeachTerrain.setScale(0.5, 0.5, 0.5)
self.BeachTerrain.setPos(200, 750, 0)
self.BeachTerrain.setHpr(90, 0, 0)
self.school = self.loader.loadModel("school/school")
self.school.reparentTo(self.render)
self.school.setScale(0.056, 0.07, 0.05)
self.school.setPos(-162, -348, 0)
self.school.setHpr(90, 0, 0)
self.car = Actor("bvw-f2004--jeep/jeep",
{"walk": "bvw-f2004--jeep/jeep-start"})
self.car.setScale(0.5, 0.5, 0.5)
self.car.reparentTo(self.render)
self.car.setPos(carx, cary, -2)
self.car.setHpr(180, 0, 0)
#print self.car
for l in range(10):
self.crate[l] = self.loader.loadModel("model" + str(l + 1) +
"/crate" + str(l + 1) +
".egg")
self.crate[l].setScale(self.sX[l], self.sY[l], self.sZ[l])
self.crate[l].reparentTo(self.render)
self.crate[l].setPos(self.posc[3 * l], self.posc[3 * l + 1], 2)
self.crate[l].setHpr(0, 0, 0)
#self.car.loop("walk")
#self.car.reparentTo(self.render)
#self.car.setScale(2,2,2)
#self.car.setPos(carx,cary,-2)
#self.car.setHpr(0,0,0)
self.museum = self.loader.loadModel("Museum/Museum")
self.museum.reparentTo(self.render)
self.museum.setScale(1, 2, 1.5)
self.museum.setPos(100, 200, 0)
self.museum.setHpr(180, 0, 0)
self.PalmTree = self.loader.loadModel("PalmTree/palmtree")
self.PalmTree.reparentTo(self.render)
self.PalmTree.setScale(2, 2, 3.5)
self.PalmTree.setPos(175, 200, 0)
self.PalmTree.setHpr(0, 0, 0)
self.stadium = self.loader.loadModel("Stadium/stadium")
self.stadium.reparentTo(self.render)
self.stadium.setScale(0.5, 0.5, 0.5)
self.stadium.setPos(13, 0, 0)
self.stadium.setHpr(0, 0, 0)
self.Junkyard = self.loader.loadModel("Junkyard")
self.Junkyard.reparentTo(self.render)
self.Junkyard.setScale(0.2, 0.4, 0.3)
self.Junkyard.setPos(150, -650 / 2 - 25, 0)
self.Junkyard.setHpr(90, 0, 0)
self.BB1 = self.loader.loadModel("BuildingCluster1")
self.BB1.reparentTo(self.render)
self.BB1.setScale(0.5, 0.5, 1)
self.BB1.setPos(-100 - 10, 650 / 2 + 20, 0)
self.BB1.setHpr(270, 0, 0)
self.BB2 = self.loader.loadModel("BB2/BuildingCluster2")
self.BB2.reparentTo(self.render)
self.BB2.setScale(0.5, 0.5, 1)
self.BB2.setPos(-60 - 10, 650 / 2 + 20, 0)
self.BB2.setHpr(270, 0, 0)
self.BB3 = self.loader.loadModel("BB3/BuildingCluster3")
self.BB3.reparentTo(self.render)
self.BB3.setScale(0.5, 0.5, 1)
self.BB3.setPos(-140 - 10, 650 / 2 + 20, 0)
self.BB3.setHpr(270, 0, 0)
self.BB4 = self.loader.loadModel("BB4/BuildingCluster4")
self.BB4.reparentTo(self.render)
self.BB4.setScale(0.5, 0.5, 1)
self.BB4.setPos(-25 - 10, 650 / 2 + 20, 0)
self.BB4.setHpr(270, 0, 0)
self.BB5 = self.loader.loadModel("BB5/BuildingCluster5")
self.BB5.reparentTo(self.render)
self.BB5.setScale(0.5, 0.5, 1)
self.BB5.setPos(-190 - 10, 650 / 2 + 20, 0)
self.BB5.setHpr(270, 0, 0)
self.BS = self.loader.loadModel("BS/blue_sky_sphere")
self.BS.reparentTo(self.render)
self.BS.setScale(1, 1, 1)
self.BS.setPos(-180, 0, 0)
self.flagMain = self.loader.loadModel("Flag/flag")
self.flagMain.setScale(0.3, 0.3, 0.3)
self.flagMain.reparentTo(self.render)
self.flagMain.setPos(carx - 20, cary, 10)
print self.flagMain
for i in range(6):
self.Truck[i] = self.loader.loadModel(
"bvw-f2004--fireengine/fireengine")
self.Truck[i].reparentTo(self.render)
self.Truck[i].setScale(2, 2, 2)
##self.Truck[i].setPos(180,0,0)
#Create the four lerp intervals needed to walk back and forth
self.setTruck()
#self.City = self.loader.loadModel("City/course2")
#self.City.reparentTo(self.render)
#self.City.setScale(2.5,2.5,2.5)
#self.City.setPos(500,0,0)
self.accept('arrow_down', self.moved, [0])
self.accept('arrow_up', self.move, [0])
self.accept("arrow_left", self.change_dc, [0])
self.accept("arrow_right", self.change_da, [0])
self.accept('arrow_down-up', self.moved, [2])
self.accept('arrow_up-up', self.move, [2])
#self.accept("arrow_left-up",self.change_dc,[2])
#self.accept("arrow_right-up",self.change_da,[2])
self.accept('arrow_down-repeat', self.moved, [1])
self.accept('arrow_up-repeat', self.move, [1])
self.accept("arrow_left-repeat", self.change_dc, [1])
self.accept("arrow_right-repeat", self.change_da, [1])
base.cTrav = CollisionTraverser()
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
self.collCount = 0
sColl = self.initCollisionSphere(self.car, 1, 1, 1, True)
base.cTrav.addCollider(sColl[0], self.collHandEvent)
self.accept('into-' + sColl[1], self.collide)
#self.accept('outof-' + sColl[1], self.collide4)
i = 0
for child in render.getChildren():
if child != self.CornField and child != camera and child != self.CityTerrain and child != self.BeachTerrain and child != self.BS and child != self.Fence1 and child != self.Fence2 and child != self.Fence3 and child != self.Fence4:
#print child
tColl = self.initCollisionSphere(child, self.radX[i],
self.radY[i], self.radZ[i],
True)
base.cTrav.addCollider(tColl[0], self.collHandEvent)
#print i
i = i + 1
# Accept the events sent by the collisions.
self.accept('into-' + tColl[1], self.collide)
for l in range(10):
self.flag[l] = self.loader.loadModel("Flag/flag")
self.flag[l].setScale(0.3, 0.3, 0.3)
self.flag[l].reparentTo(self.render)
self.flag[l].setPos(self.posc[3 * l], self.posc[3 * l + 1], 10)
# self.accept( 'into-' + sColl[1], self.collide)
#self.accept('outof-' + tColl[1], self.collide2)
# print carx,cary
# cs = CollisionSphere(0, 0, 0, 10)
# fromObject = self.car.attachNewNode(CollisionNode('cnode'))
# fromObject.node().addSolid(cs)
# fromObject.show()
# pusher = CollisionHandlerPusher()
# pusher.addCollider(fromObject, self.car)
# base.cTrav = CollisionTraverser()
# base.cTrav.addCollider(fromObject, pusher)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
def collide(self, collEntry):
global carx, cary, car_def, a, Num, count
#print "Collide"
#print collEntry.getFromNodePath().getParent()
#for objectc in collEntry:
for l in range(10):
#print collEntry.getFromNodePath().getParent()
if collEntry.getIntoNodePath().getParent() == self.crate[l]:
collEntry.getIntoNodePath().getParent().remove()
#print "Baba"
Num = l
count = count - 1
self.flag[l].hide()
self.Game_Point()
if str(collEntry.getIntoNodePath().getParent()
) == "render/flag.egg" and count == 0 and str(
collEntry.getFromNodePath().getParent(
)) == "render/jeepNman_loop_baked":
#print "here"
self.GameOver()
if str(collEntry.getIntoNodePath().getParent(
)) == "render/jeepNman_loop_baked" or str(collEntry.getFromNodePath(
).getParent()) == "render/jeepNman_loop_baked":
if a == 0:
if self.car.getH() == 45:
carx = carx + car_def
cary = cary - car_def
if self.car.getH() == 90:
carx = carx + car_def
if self.car.getH() == 135:
carx = carx + car_def
cary = cary + car_def
if self.car.getH() == 180:
cary = cary + car_def
if self.car.getH() == 225:
carx = carx - car_def
cary = cary + car_def
if self.car.getH() == 270:
carx = carx - car_def
if self.car.getH() == 315:
carx = carx - car_def
cary = cary - car_def
if self.car.getH() == 0:
cary = cary - car_def
if a == 1:
car_def = -1 * car_def
if self.car.getH() == 45:
carx = carx + car_def
cary = cary - car_def
if self.car.getH() == 90:
carx = carx + car_def
if self.car.getH() == 135:
carx = carx + car_def
cary = cary + car_def
if self.car.getH() == 180:
cary = cary + car_def
if self.car.getH() == 225:
carx = carx - car_def
cary = cary + car_def
if self.car.getH() == 270:
carx = carx - car_def
if self.car.getH() == 315:
carx = carx - car_def
cary = cary - car_def
if self.car.getH() == 0:
cary = cary - car_def
car_def = -1 * car_def
# def collide2(self,collEntry):
#
# def collide3(self,collEntry):
# global carx , cary
# carx=carx-2
# cary=cary-2
# def collide4(self,collEntry):
# print 4
def initCollisionSphere(self, obj, setX, setY, setZ, show=False):
# Get the size of the object for the collision sphere.
bounds = obj.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius() * 0.6
# Create a collision sphere and name it something understandable.
collSphereStr = 'CollisionHull' + str(
self.collCount) + "_" + obj.getName()
self.collCount += 1
self.accept('arrow_down', self.moved, [0])
self.accept('arrow_up', self.move, [0])
cNode = CollisionNode(collSphereStr)
# cNode.setScale(3,3,3)
cNode.addSolid(CollisionSphere(center, radius))
cNodepath = obj.attachNewNode(cNode)
cNodepath.setScale(setX, setY, setZ)
#cNodepath.show()
# Return a tuple with the collision node and its corrsponding string so
# that the bitmask can be set.
return (cNodepath, collSphereStr)
def moved(self, i):
global carx, cary, camx, camy, dis, a
#print "moved"
a = 1
if i == 0:
#print "Hello"
self.car.loop("walk")
if i == 2:
self.car.stop("walk")
#print "hello",self.car.getH()
#print base.camera.getH()
if carx > -410 and carx < 410 and cary > -410 and cary < 410:
if self.car.getH() == 45:
carx = carx - car_speed
cary = cary + car_speed
camx = carx - dis
camy = cary + dis
if self.car.getH() == 90:
carx = carx - car_speed
camx = carx - dis
if self.car.getH() == 135:
carx = carx - car_speed
cary = cary - car_speed
camx = carx - dis
camy = cary - dis
if self.car.getH() == 180:
cary = cary - car_speed
camy = cary - dis
if self.car.getH() == 225:
carx = carx + car_speed
cary = cary - car_speed
camx = carx + dis
camy = cary - dis
if self.car.getH() == 270:
carx = carx + car_speed
camx = carx + dis
if self.car.getH() == 315:
carx = carx + car_speed
cary = cary + car_speed
camx = carx + dis
camy = cary + dis
if self.car.getH() == 0:
cary = cary + car_speed
camy = cary + dis
else:
if carx <= -410:
carx = carx - 1
if carx >= 410:
carx = carx + 1
if cary <= -410:
cary = cary - 1
if cary >= 410:
cary = cary + 1
def move(self, i):
global carx, cary, camx, camy, dis, a
a = 0
# print "move"
# print carx,cary
if i == 0:
self.car.loop("walk")
if i == 2:
self.car.stop("walk")
#print "hello",self.car.getH()
#print base.camera.getH()
if carx > -410 and carx < 410 and cary > -410 and cary < 410:
if self.car.getH() == 45:
carx = carx + car_speed
cary = cary - car_speed
camx = carx + dis
camy = cary - dis
if self.car.getH() == 90:
carx = carx + car_speed
camx = carx + dis
if self.car.getH() == 135:
carx = carx + car_speed
cary = cary + car_speed
camx = carx + dis
camy = cary + dis
if self.car.getH() == 180:
cary = cary + car_speed
camy = cary + dis
if self.car.getH() == 225:
carx = carx - car_speed
cary = cary + car_speed
camx = carx - dis
camy = cary + dis
if self.car.getH() == 270:
carx = carx - car_speed
camx = carx - dis
if self.car.getH() == 315:
carx = carx - car_speed
cary = cary - car_speed
camx = carx - dis
camy = cary - dis
if self.car.getH() == 0:
cary = cary - car_speed
camy = cary - car_speed
else:
if carx <= -410:
carx = carx + 1
if carx >= 410:
carx = carx - 1
if cary <= -410:
cary = cary + 1
if cary >= 410:
cary = cary - 1
# self.car.loop("walk")
def change_dc(self, i):
global d
#if i ==0:
# print "Hello"
# self.car.loop("walk")
#if i==2:
# self.car.stop("walk")
d = d + 45
d = d % 360
def change_da(self, i):
global d
#if i ==0:
# print "Hello"
# self.car.loop("walk")
#if i==2:
# self.car.stop("walk")
d = d - 45
d = d % 360
#for j in range(9):
# d=d - 5
#
# d=d % 360
# self.car.setHpr(d , 0 , 0)
# time.sleep(0.1)
#messenger.send('arrow_up-repeat')
def spinCameraTask(self, task):
global time, carx, cary, d, dis, camx, camy, count, cor_ans
time = int(task.time)
#r = d * (pi / 180.0)
#print carx,cary
if self.car.getH() == 45:
camx = carx - dis
camy = cary + dis
if self.car.getH() == 90:
camx = carx - 1.41 * dis
camy = cary
if self.car.getH() == 135:
camx = carx - dis
camy = cary - dis
if self.car.getH() == 180:
camy = cary - 1.41 * dis
camx = carx
if self.car.getH() == 225:
camx = carx + dis
camy = cary - dis
if self.car.getH() == 270:
camx = carx + 1.41 * dis
camy = cary
if self.car.getH() == 315:
camx = carx + dis
camy = cary + dis
if self.car.getH() == 0:
camy = cary + 1.41 * dis
camx = carx
if h == 0:
self.inst1.destroy()
self.inst2.destroy()
self.inst3.destroy()
self.inst1 = addInstructions(0.89,
"Correct Answer: " + str(cor_ans))
self.inst2 = addInstructions(0.95, "Time: " + str(time))
self.inst3 = addInstructions(0.84,
"Waste Reamaining " + str(count / 2))
self.car.setPos(carx, cary, 0)
self.car.setHpr(d, 0, 0)
base.camera.setPos(camx, camy, 5)
base.camera.setHpr(d + 180, 0, 0)
#base.camera.setPos(0,0,1700)
#base.camera.setHpr(0, -90 , 0)
return Task.cont
# base.camera.setPos(0,-40,3)
# return Task.cont
def setTruck(self):
pandaPosInterval01 = self.Truck[0].posInterval(11,
Point3(18, 138, 0),
startPos=Point3(
21, 390, 0))
pandaPosInterval02 = self.Truck[0].posInterval(5,
Point3(140, 132, 0),
startPos=Point3(
18, 138, 0))
pandaPosInterval03 = self.Truck[0].posInterval(10,
Point3(140, -123, 0),
startPos=Point3(
140, 132, 0))
pandaPosInterval04 = self.Truck[0].posInterval(5,
Point3(-7, -126, 0),
startPos=Point3(
140, -123, 0))
pandaPosInterval05 = self.Truck[0].posInterval(11,
Point3(-10, -399, 0),
startPos=Point3(
-7, -126, 0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval00 = self.Truck[0].hprInterval(1,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval01 = self.Truck[0].hprInterval(3,
Point3(-90, 0, 0),
startHpr=Point3(
180, 0, 0))
pandaHprInterval02 = self.Truck[0].hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
-90, 0, 0))
pandaHprInterval03 = self.Truck[0].hprInterval(3,
Point3(90, 0, 0),
startHpr=Point3(
180, 0, 0))
pandaHprInterval04 = self.Truck[0].hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
90, 0, 0))
#pandaHprInterval5= self.Truck[0].hprInterif collEntry.getIntoNodePath().getParent() == self.crate[l]:val(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace0 = Sequence(pandaHprInterval00,
pandaPosInterval01,
pandaHprInterval01,
pandaPosInterval02,
pandaHprInterval02,
pandaPosInterval03,
pandaHprInterval03,
pandaPosInterval04,
pandaHprInterval04,
pandaPosInterval05,
name="pandaPace0")
pandaPace0.loop()
pandaPosInterval11 = self.Truck[1].posInterval(11,
Point3(-126, 14, 0),
startPos=Point3(
-411, 14, 0))
pandaPosInterval12 = self.Truck[1].posInterval(5,
Point3(-117, 145, 0),
startPos=Point3(
-126, 14, 0))
pandaPosInterval13 = self.Truck[1].posInterval(10,
Point3(148, 130, 0),
startPos=Point3(
-117, 145, 0))
pandaPosInterval14 = self.Truck[1].posInterval(5,
Point3(145, -5, 0),
startPos=Point3(
148, 130, 0))
pandaPosInterval15 = self.Truck[1].posInterval(11,
Point3(394, -8, 0),
startPos=Point3(
145, -5, 0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval10 = self.Truck[1].hprInterval(1,
Point3(-90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval11 = self.Truck[1].hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
-90, 0, 0))
pandaHprInterval12 = self.Truck[1].hprInterval(3,
Point3(-90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval13 = self.Truck[1].hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
-90, 0, 0))
pandaHprInterval14 = self.Truck[1].hprInterval(3,
Point3(-90, 0, 0),
startHpr=Point3(
180, 0, 0))
#pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace1 = Sequence(pandaHprInterval10,
pandaPosInterval11,
pandaHprInterval11,
pandaPosInterval12,
pandaHprInterval12,
pandaPosInterval13,
pandaHprInterval13,
pandaPosInterval14,
pandaHprInterval14,
pandaPosInterval15,
name="pandaPace1")
pandaPace1.loop()
pandaPosInterval21 = self.Truck[2].posInterval(11,
Point3(-9, -144, 0),
startPos=Point3(
-6, -358, 0))
pandaPosInterval22 = self.Truck[2].posInterval(5,
Point3(-129, -137, 0),
startPos=Point3(
-9, -144, 0))
pandaPosInterval23 = self.Truck[2].posInterval(10,
Point3(-129, 142, 0),
startPos=Point3(
-129, -137, 0))
pandaPosInterval24 = self.Truck[2].posInterval(5,
Point3(5, 145, 0),
startPos=Point3(
-129, 142, 0))
pandaPosInterval25 = self.Truck[2].posInterval(11,
Point3(20, 395, 0),
startPos=Point3(
5, 145, 0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval20 = self.Truck[2].hprInterval(1,
Point3(0, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval21 = self.Truck[2].hprInterval(3,
Point3(90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval22 = self.Truck[2].hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
90, 0, 0))
pandaHprInterval23 = self.Truck[2].hprInterval(3,
Point3(-90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval24 = self.Truck[2].hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
-90, 0, 0))
#pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace2 = Sequence(pandaHprInterval20,
pandaPosInterval21,
pandaHprInterval21,
pandaPosInterval22,
pandaHprInterval22,
pandaPosInterval23,
pandaHprInterval23,
pandaPosInterval24,
pandaHprInterval24,
pandaPosInterval25,
name="pandaPace2")
pandaPace2.loop()
pandaPosInterval31 = self.Truck[3].posInterval(11,
Point3(150, -18, 0),
startPos=Point3(
408, -18, 0))
pandaPosInterval32 = self.Truck[3].posInterval(5,
Point3(147, -135, 0),
startPos=Point3(
150, -18, 0))
pandaPosInterval33 = self.Truck[3].posInterval(10,
Point3(-120, -138, 0),
startPos=Point3(
147, -135, 0))
pandaPosInterval34 = self.Truck[3].posInterval(5,
Point3(-123, -6, 0),
startPos=Point3(
-120, -138, 0))
pandaPosInterval35 = self.Truck[3].posInterval(11,
Point3(-396, 10, 0),
startPos=Point3(
-123, -6, 0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval30 = self.Truck[3].hprInterval(1,
Point3(90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval31 = self.Truck[3].hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
90, 0, 0))
pandaHprInterval32 = self.Truck[3].hprInterval(3,
Point3(90, 0, 0),
startHpr=Point3(
180, 0, 0))
pandaHprInterval33 = self.Truck[3].hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
90, 0, 0))
pandaHprInterval34 = self.Truck[3].hprInterval(3,
Point3(90, 0, 0),
startHpr=Point3(
0, 0, 0))
#pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace4 = Sequence(pandaHprInterval30,
pandaPosInterval31,
pandaHprInterval31,
pandaPosInterval32,
pandaHprInterval32,
pandaPosInterval33,
pandaHprInterval33,
pandaPosInterval34,
pandaHprInterval34,
pandaPosInterval35,
name="pandaPace4")
pandaPace4.loop()
pandaPosInterval41 = self.Truck[4].posInterval(12,
Point3(298, -282, 0),
startPos=Point3(
-276, -282, 0))
pandaPosInterval42 = self.Truck[4].posInterval(12,
Point3(286, 280, 0),
startPos=Point3(
298, -282, 0))
pandaPosInterval43 = self.Truck[4].posInterval(12,
Point3(-268, 280, 0),
startPos=Point3(
286, 280, 0))
pandaPosInterval44 = self.Truck[4].posInterval(12,
Point3(-276, -282, 0),
startPos=Point3(
-268, 280, 0))
#pandaHprInterval30= self.Truck[3].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval41 = self.Truck[4].hprInterval(3,
Point3(-90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval42 = self.Truck[4].hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
-90, 0, 0))
pandaHprInterval43 = self.Truck[4].hprInterval(3,
Point3(90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval44 = self.Truck[4].hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
90, 0, 0))
#pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace5 = Sequence(pandaHprInterval41,
pandaPosInterval41,
pandaHprInterval42,
pandaPosInterval42,
pandaHprInterval43,
pandaPosInterval43,
pandaHprInterval44,
pandaPosInterval44,
name="pandaPace5")
pandaPace5.loop()
pandaPosInterval51 = self.Truck[5].posInterval(12,
Point3(-268, 280, 0),
startPos=Point3(
286, 280, 0))
pandaPosInterval52 = self.Truck[5].posInterval(12,
Point3(-276, -282, 0),
startPos=Point3(
-268, 280, 0))
pandaPosInterval53 = self.Truck[5].posInterval(12,
Point3(298, -282, 0),
startPos=Point3(
-276, -282, 0))
pandaPosInterval54 = self.Truck[5].posInterval(12,
Point3(286, 280, 0),
startPos=Point3(
298, -282, 0))
#pandaPosInterval55= self.Truck[5].posInterval(13,Point3(-396,10,0), startPos=Point3(-123,-6,0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
#pandaHprInterval50= self.Truck[5].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval51 = self.Truck[5].hprInterval(3,
Point3(90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval52 = self.Truck[5].hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
90, 0, 0))
pandaHprInterval53 = self.Truck[5].hprInterval(3,
Point3(-90, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval54 = self.Truck[5].hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
-90, 0, 0))
#pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace6 = Sequence(pandaHprInterval51,
pandaPosInterval51,
pandaHprInterval52,
pandaPosInterval52,
pandaHprInterval53,
pandaPosInterval53,
pandaHprInterval54,
pandaPosInterval54,
name="pandaPace6")
pandaPace6.loop()
def Game_Point(self):
self.ignore("arrow_down")
self.ignore("arrow_up")
self.ignore("arrow_down-repeat")
self.ignore("arrow_up-repeat")
#self.text1 = addInstructions(0.5,"Is this Recyclable")
self.text1 = TextNode('t1')
self.text1.setText("is This Recyclable")
self.text1.setTextColor(0, 0, 0, 1)
self.textNodePath1 = aspect2d.attachNewNode(self.text1)
self.textNodePath1.setScale(0.07)
self.textNodePath1.setPos(-0.1, -0.1, 0.1)
#text1.setTextColor(1,1,1)
self.text1.setFrameColor(1, 0, 0, 1)
self.text1.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
self.text2 = TextNode('t2')
self.text2.setText("Y/N")
self.text2.setTextColor(0, 0, 0, 1)
self.textNodePath2 = aspect2d.attachNewNode(self.text2)
self.textNodePath2.setScale(0.07)
self.textNodePath2.setPos(0, 0, 0)
#textNodePath2.setTextColor(1,1,1)
self.text2.setFrameColor(1, 0, 0, 1)
self.text2.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
self.accept('y', self.answer, [0])
self.accept('n', self.answer, [1])
def answer(self, n):
global Num, cor_ans
#print self.ans[Num]
self.accept('arrow_down', self.moved, [0])
self.accept('arrow_up', self.move, [0])
self.accept('arrow_down-repeat', self.moved, [1])
self.accept('arrow_up-repeat', self.move, [1])
aspect2d.getChildren().detach()
if n == 0:
if self.ans[Num] == 'Y':
cor_ans = cor_ans + 1
if n == 1:
if self.ans[Num] == 'N':
#print "Correct"
cor_ans = cor_ans + 1
self.ignore('y')
self.ignore('n')
#print "Hello"
def GameOver(self):
global cor_ans, time, h
h = 1
#print time
for x in self.render.getChildren():
x.detachNode()
self.inst1.destroy()
self.inst2.destroy()
self.inst3.destroy()
self.text3 = TextNode('t1')
self.text3.setText("Game Over ")
self.text3.setTextColor(1, 0, 0, 1)
self.textNodePath3 = aspect2d.attachNewNode(self.text3)
self.textNodePath3.setScale(0.1)
self.textNodePath3.setPos(-0.1, -0.1, 0.2)
#text1.setTextColor(1,1,1)
#self.text3.setFrameColor(1, 0, 0, 1)
#self.text3.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
self.text5 = TextNode('t1')
self.text5.setText("Time Taken: " + str(time))
self.text5.setTextColor(1, 0, 0, 1)
self.textNodePath5 = aspect2d.attachNewNode(self.text5)
self.textNodePath5.setScale(0.1)
self.textNodePath5.setPos(-0.1, -0.1, 0)
self.text6 = TextNode('t1')
self.text6.setText("correct answer: " + str(cor_ans))
self.text6.setTextColor(1, 0, 0, 1)
self.textNodePath6 = aspect2d.attachNewNode(self.text6)
self.textNodePath6.setScale(0.1)
self.textNodePath6.setPos(-0.1, -0.1, -0.2)
self.text4 = TextNode('t2')
self.text4.setText("Score: " + str(5000 / time + (cor_ans * 10)))
self.text4.setTextColor(1, 0, 0, 1)
self.textNodePath4 = aspect2d.attachNewNode(self.text4)
self.textNodePath4.setScale(0.1)
self.textNodePath4.setPos(-0.1, -0.1, -0.4)
class DistributedGolfSpot(DistributedObject.DistributedObject, FSM.FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGolfSpot')
positions = ((-45, 100, GolfGlobals.GOLF_BALL_RADIUS),
(-15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(45, 100, GolfGlobals.GOLF_BALL_RADIUS))
toonGolfOffsetPos = Point3(-2, 0, -GolfGlobals.GOLF_BALL_RADIUS)
toonGolfOffsetHpr = Point3(-90, 0, 0)
rotateSpeed = 20
golfPowerSpeed = base.config.GetDouble('golf-power-speed', 3)
golfPowerExponent = base.config.GetDouble('golf-power-exponent', 0.75)
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.FSM.__init__(self, 'DistributedGolfSpot')
self.boss = None
self.index = None
self.avId = 0
self.toon = None
self.golfSpotSmoother = SmoothMover()
self.golfSpotSmoother.setSmoothMode(SmoothMover.SMOn)
self.smoothStarted = 0
self.__broadcastPeriod = 0.2
if self.index > len(self.positions):
self.notify.error('Invalid index %d' % index)
self.fadeTrack = None
self.setupPowerBar()
self.aimStart = None
self.golfSpotAdviceLabel = None
self.changeSeq = 0
self.lastChangeSeq = 0
self.controlKeyAllowed = False
self.flyBallTracks = {}
self.splatTracks = {}
self.__flyBallBubble = None
self.flyBallHandler = None
self.__flyBallSequenceNum = 0
self.swingInterval = None
self.lastHitSequenceNum = -1
self.goingToReward = False
self.gotHitByBoss = False
self.releaseTrack = None
self.grabTrack = None
self.restoreScaleTrack = None
return
def setBossCogId(self, bossCogId):
self.bossCogId = bossCogId
self.boss = base.cr.doId2do[bossCogId]
self.boss.setGolfSpot(self, self.index)
def setIndex(self, index):
self.index = index
def disable(self):
DistributedObject.DistributedObject.disable(self)
self.ignoreAll()
def delete(self):
DistributedObject.DistributedObject.delete(self)
self.ignoreAll()
self.boss = None
return
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.triggerName = self.uniqueName('trigger')
self.triggerEvent = 'enter%s' % self.triggerName
self.smoothName = self.uniqueName('golfSpotSmooth')
self.golfSpotAdviceName = self.uniqueName('golfSpotAdvice')
self.posHprBroadcastName = self.uniqueName('golfSpotBroadcast')
self.ballPowerTaskName = self.uniqueName('updateGolfPower')
self.adjustClubTaskName = self.uniqueName('adjustClub')
self.loadAssets()
self.accept('flyBallHit-%d' % self.index, self.__flyBallHit)
def loadAssets(self):
self.root = render.attachNewNode('golfSpot-%d' % self.index)
self.root.setPos(*self.positions[self.index])
self.ballModel = loader.loadModel('phase_6/models/golf/golf_ball')
self.ballColor = VBase4(1, 1, 1, 1)
if self.index < len(GolfGlobals.PlayerColors):
self.ballColor = VBase4(*GolfGlobals.PlayerColors[self.index])
self.ballModel.setColorScale(self.ballColor)
self.ballModel.reparentTo(self.root)
self.club = loader.loadModel('phase_6/models/golf/putter')
self.clubLookatSpot = self.root.attachNewNode('clubLookat')
self.clubLookatSpot.setY(-(GolfGlobals.GOLF_BALL_RADIUS + 0.1))
cs = CollisionSphere(0, 0, 0, 1)
cs.setTangible(0)
cn = CollisionNode(self.triggerName)
cn.addSolid(cs)
cn.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.trigger = self.root.attachNewNode(cn)
self.trigger.stash()
self.hitBallSfx = loader.loadSfx('phase_6/audio/sfx/Golf_Hit_Ball.ogg')
def cleanup(self):
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if self.releaseTrack:
self.releaseTrack.finish()
self.releaseTrack = None
flyTracks = self.flyBallTracks.values()
for track in flyTracks:
track.finish()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
if self.restoreScaleTrack:
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
self.root.removeNode()
self.ballModel.removeNode()
self.club.removeNode()
if self.powerBar:
self.powerBar.destroy()
self.powerBar = None
taskMgr.remove(self.triggerName)
self.boss = None
return
def setState(self, state, avId, extraInfo):
if not self.isDisabled():
self.gotHitByBoss = extraInfo
if state == 'C':
self.demand('Controlled', avId)
elif state == 'F':
self.demand('Free')
elif state == 'O':
self.demand('Off')
else:
self.notify.error('Invalid state from AI: %s' % state)
def enterOff(self):
pass
def exitOff(self):
pass
def enterFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack = Sequence(Wait(6),
self.getRestoreScaleInterval(),
name='restoreScaleTrack')
self.restoreScaleTrack.start()
if self.avId == localAvatar.doId:
if not self.isDisabled():
self.ballModel.setAlphaScale(0.3)
self.ballModel.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(Func(self.ballModel.setTransparency,
1),
self.ballModel.colorScaleInterval(
0.2, VBase4(1, 1, 1, 0.3)),
name='fadeTrack-enterFree')
self.fadeTrack.start()
else:
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
self.avId = 0
return
def exitFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
taskMgr.remove(self.triggerName)
self.ballModel.clearTransparency()
self.trigger.stash()
self.ignore(self.triggerEvent)
return
def enterControlled(self, avId):
self.avId = avId
toon = base.cr.doId2do.get(avId)
if not toon:
return
self.enableControlKey()
self.toon = toon
self.grabTrack = self.makeToonGrabInterval(toon)
if avId == localAvatar.doId:
self.boss.toCraneMode()
camera.reparentTo(self.root)
camera.setPosHpr(0, -10, 3, 0, 0, 0)
localAvatar.setPos(self.root, self.toonGolfOffsetPos)
localAvatar.setHpr(self.root, self.toonGolfOffsetHpr)
localAvatar.sendCurrentPosition()
self.__enableControlInterface()
self.startPosHprBroadcast()
self.accept('exitCrane', self.gotBossZapped)
self.grabTrack.start()
def exitControlled(self):
self.grabTrack.finish()
del self.grabTrack
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if not self.ballModel.isEmpty():
if self.ballModel.isHidden():
self.notify.debug('ball is hidden scale =%s' %
self.ballModel.getScale())
else:
self.notify.debug('ball is showing scale=%s' %
self.ballModel.getScale())
if self.toon and not self.toon.isDisabled():
self.toon.startSmooth()
self.releaseTrack = self.makeToonReleaseInterval(self.toon)
self.stopPosHprBroadcast()
self.stopSmooth()
if self.avId == localAvatar.doId:
self.__disableControlInterface()
if not self.goingToReward:
camera.reparentTo(base.localAvatar)
camera.setPos(base.localAvatar.cameraPositions[0][0])
camera.setHpr(0, 0, 0)
self.stopAdjustClubTask()
self.releaseTrack.start()
self.enableControlKey()
return
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(self.ballModel.colorScaleInterval(
0.2, self.ballColor),
Func(self.ballModel.clearTransparency),
name='fadeTrack-allowDetect')
self.fadeTrack.start()
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
def __hitTrigger(self, event):
self.d_requestControl()
def getRestoreScaleInterval(self):
return Sequence()
def d_requestControl(self):
self.sendUpdate('requestControl')
def d_requestFree(self, gotHitByBoss):
self.sendUpdate('requestFree', [gotHitByBoss])
def makeToonGrabInterval(self, toon):
origPos = toon.getPos(self.root)
origHpr = toon.getHpr(self.root)
a = self.accomodateToon(toon)
newPos = toon.getPos()
newHpr = toon.getHpr()
origHpr.setX(PythonUtil.fitSrcAngle2Dest(origHpr[0], newHpr[0]))
self.notify.debug('toon.setPosHpr %s %s' % (origPos, origHpr))
toon.setPosHpr(origPos, origHpr)
walkTime = 0.2
reach = Sequence()
if reach.getDuration() < walkTime:
reach = Sequence(
ActorInterval(toon,
'walk',
loop=1,
duration=walkTime - reach.getDuration()), reach)
i = Sequence(
Parallel(toon.posInterval(walkTime, newPos, origPos),
toon.hprInterval(walkTime, newHpr, origHpr), reach),
Func(toon.stopLookAround))
if toon == base.localAvatar:
i.append(Func(self.switchToAnimState, 'GolfPuttLoop'))
i.append(Func(self.startAdjustClubTask))
i = Parallel(i, a)
return i
def accomodateToon(self, toon):
toon.wrtReparentTo(self.root)
toon.setPos(self.toonGolfOffsetPos)
toon.setHpr(self.toonGolfOffsetHpr)
return Sequence()
def switchToAnimState(self, animStateName, forced=False):
curAnimState = base.localAvatar.animFSM.getCurrentState()
curAnimStateName = ''
if curAnimState:
curAnimStateName = curAnimState.getName()
if curAnimStateName != animStateName or forced:
base.localAvatar.b_setAnimState(animStateName)
def __enableControlInterface(self):
gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'),
gui.find('**/CloseBtn_DN'),
gui.find('**/CloseBtn_Rllvr'),
gui.find('**/CloseBtn_UP')),
relief=None,
scale=2,
text=TTLocalizer.BossbotGolfSpotLeave,
text_scale=0.04,
text_pos=(0, -0.07),
text_fg=VBase4(1, 1, 1, 1),
pos=(1.05, 0, -0.82),
command=self.__exitGolfSpot)
self.accept('escape', self.__exitGolfSpot)
self.accept('control', self.__controlPressed)
self.accept('control-up', self.__controlReleased)
self.accept('InputState-forward', self.__upArrow)
self.accept('InputState-reverse', self.__downArrow)
self.accept('InputState-turnLeft', self.__leftArrow)
self.accept('InputState-turnRight', self.__rightArrow)
taskMgr.add(self.__watchControls, 'watchGolfSpotControls')
taskMgr.doMethodLater(5, self.__displayGolfSpotAdvice,
self.golfSpotAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
if self.powerBar:
self.powerBar.show()
return
def __disableControlInterface(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = None
self.__cleanupGolfSpotAdvice()
self.ignore('escape')
self.ignore('control')
self.ignore('control-up')
self.ignore('InputState-forward')
self.ignore('InputState-reverse')
self.ignore('InputState-turnLeft')
self.ignore('InputState-turnRight')
self.arrowVert = 0
self.arrowHorz = 0
taskMgr.remove('watchGolfSpotControls')
if self.powerBar:
self.powerBar.hide()
else:
self.notify.debug('self.powerBar is none')
return
def setupPowerBar(self):
self.powerBar = DirectWaitBar(pos=(0.0, 0, -0.94),
relief=DGG.SUNKEN,
frameSize=(-2.0, 2.0, -0.2, 0.2),
borderWidth=(0.02, 0.02),
scale=0.25,
range=100,
sortOrder=50,
frameColor=(0.5, 0.5, 0.5, 0.5),
barColor=(1.0, 0.0, 0.0, 1.0),
text='',
text_scale=0.26,
text_fg=(1, 1, 1, 1),
text_align=TextNode.ACenter,
text_pos=(0, -0.05))
self.power = 0
self.powerBar['value'] = self.power
self.powerBar.hide()
def resetPowerBar(self):
self.power = 0
self.powerBar['value'] = self.power
self.powerBar['text'] = ''
def __displayGolfSpotAdvice(self, task):
if self.golfSpotAdviceLabel == None:
self.golfSpotAdviceLabel = DirectLabel(
text=TTLocalizer.BossbotGolfSpotAdvice,
text_fg=VBase4(1, 1, 1, 1),
text_align=TextNode.ACenter,
relief=None,
pos=(0, 0, 0.69),
scale=0.1)
return
def __cleanupGolfSpotAdvice(self):
if self.golfSpotAdviceLabel:
self.golfSpotAdviceLabel.destroy()
self.golfSpotAdviceLabel = None
taskMgr.remove(self.golfSpotAdviceName)
return
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(
relief=None,
text=TTLocalizer.BossbotGolfSpotLeaving,
pos=(1.05, 0, -0.88),
text_pos=(0, 0),
text_scale=0.06,
text_fg=VBase4(1, 1, 1, 1))
self.__cleanupGolfSpotAdvice()
return
def __exitGolfSpot(self):
self.d_requestFree(False)
def __controlPressed(self):
if self.controlKeyAllowed:
self.__beginFireBall()
def __controlReleased(self):
if self.controlKeyAllowed:
self.__endFireBall()
def __upArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = 1
elif self.arrowVert > 0:
self.arrowVert = 0
def __downArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = -1
elif self.arrowVert < 0:
self.arrowVert = 0
def __rightArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = 1
self.switchToAnimState('GolfRotateLeft')
elif self.arrowHorz > 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __leftArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = -1
self.switchToAnimState('GolfRotateRight')
elif self.arrowHorz < 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __watchControls(self, task):
if self.arrowHorz:
self.__moveGolfSpot(self.arrowHorz)
return Task.cont
def __moveGolfSpot(self, xd):
dt = globalClock.getDt()
h = self.root.getH() - xd * self.rotateSpeed * dt
h %= 360
limitH = h
self.root.setH(limitH)
def __incrementChangeSeq(self):
self.changeSeq = self.changeSeq + 1 & 255
def __beginFireBall(self):
if self.aimStart != None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
time = globalClock.getFrameTime()
self.aimStart = time
messenger.send('wakeup')
taskMgr.add(self.__updateBallPower, self.ballPowerTaskName)
return
def __endFireBall(self):
if self.aimStart == None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
taskMgr.remove(self.ballPowerTaskName)
self.disableControlKey()
messenger.send('wakeup')
self.aimStart = None
power = self.power
angle = self.root.getH()
self.notify.debug('incrementing self.__flyBallSequenceNum')
self.__flyBallSequenceNum = (self.__flyBallSequenceNum + 1) % 255
self.sendSwingInfo(power, angle, self.__flyBallSequenceNum)
self.setSwingInfo(power, angle, self.__flyBallSequenceNum)
self.resetPowerBar()
return
def __updateBallPower(self, task):
if not self.powerBar:
print '### no power bar!!!'
return task.done
newPower = self.__getBallPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar['value'] = newPower
return task.cont
def __getBallPower(self, time):
elapsed = max(time - self.aimStart, 0.0)
t = elapsed / self.golfPowerSpeed
t = math.pow(t, self.golfPowerExponent)
power = int(t * 100) % 200
if power > 100:
power = 200 - power
return power
def stopPosHprBroadcast(self):
taskName = self.posHprBroadcastName
taskMgr.remove(taskName)
def startPosHprBroadcast(self):
taskName = self.posHprBroadcastName
self.b_clearSmoothing()
self.d_sendGolfSpotPos()
taskMgr.remove(taskName)
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast,
taskName)
def __posHprBroadcast(self, task):
self.d_sendGolfSpotPos()
taskName = self.posHprBroadcastName
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast,
taskName)
return Task.done
def d_sendGolfSpotPos(self):
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate(
'setGolfSpotPos',
[self.changeSeq, self.root.getH(), timestamp])
def setGolfSpotPos(self, changeSeq, h, timestamp):
self.changeSeq = changeSeq
if self.smoothStarted:
now = globalClock.getFrameTime()
local = globalClockDelta.networkToLocalTime(timestamp, now)
self.golfSpotSmoother.setH(h)
self.golfSpotSmoother.setTimestamp(local)
self.golfSpotSmoother.markPosition()
else:
self.root.setH(h)
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate('clearSmoothing', [0])
def clearSmoothing(self, bogus=None):
self.golfSpotSmoother.clearPositions(1)
def doSmoothTask(self, task):
self.golfSpotSmoother.computeAndApplySmoothHpr(self.root)
return Task.cont
def startSmooth(self):
if not self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.reloadPosition()
taskMgr.add(self.doSmoothTask, taskName)
self.smoothStarted = 1
def stopSmooth(self):
if self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.forceToTruePosition()
self.smoothStarted = 0
def makeToonReleaseInterval(self, toon):
def getSlideToPos(toon=toon):
return render.getRelativePoint(toon, Point3(0, -5, 0))
if self.gotHitByBoss:
grabIval = Sequence(Func(self.detachClub),
name='makeToonReleaseInterval-gotHitByBoss')
if not toon.isEmpty():
toonIval = Sequence(Func(toon.wrtReparentTo, render),
Parallel(
ActorInterval(toon, 'slip-backward'),
toon.posInterval(0.5,
getSlideToPos,
fluid=1)),
name='makeToonReleaseInterval-toonIval')
grabIval.append(toonIval)
else:
grabIval = Sequence(Func(self.detachClub))
if not toon.isEmpty():
toonIval = Sequence(
Parallel(
ActorInterval(toon,
'walk',
duration=1.0,
playRate=-1.0),
LerpPosInterval(toon,
duration=1.0,
pos=Point3(-10, 0, 0))),
Func(toon.wrtReparentTo, render))
grabIval.append(toonIval)
if localAvatar.doId == toon.doId:
if not self.goingToReward and toon.hp > 0:
grabIval.append(Func(self.goToFinalBattle))
grabIval.append(
Func(self.notify.debug, 'goingToFinalBattlemode'))
grabIval.append(Func(self.safeBossToFinalBattleMode))
return grabIval
def safeBossToFinalBattleMode(self):
if self.boss:
self.boss.toFinalBattleMode()
def goToFinalBattle(self):
if self.cr:
place = self.cr.playGame.getPlace()
if place and hasattr(place, 'fsm'):
curState = place.fsm.getCurrentState().getName()
if place.fsm.getCurrentState().getName() == 'crane':
place.setState('finalBattle')
else:
self.notify.debug('NOT going to final battle, state=%s' %
curState)
def attachClub(self, avId, pointToBall=False):
club = self.club
if club:
av = base.cr.doId2do.get(avId)
if av:
av.useLOD(1000)
lHand = av.getLeftHands()[0]
club.setPos(0, 0, 0)
club.reparentTo(lHand)
netScale = club.getNetTransform().getScale()[1]
counterActToonScale = lHand.find('**/counteractToonScale')
if counterActToonScale.isEmpty():
counterActToonScale = lHand.attachNewNode(
'counteractToonScale')
counterActToonScale.setScale(1 / netScale)
self.notify.debug('creating counterActToonScale for %s' %
av.getName())
club.reparentTo(counterActToonScale)
club.setX(-0.25 * netScale)
if pointToBall:
club.lookAt(self.clubLookatSpot)
def detachClub(self):
if not self.club.isEmpty():
self.club.reparentTo(self.root)
self.club.setZ(-20)
self.club.setScale(1)
def adjustClub(self):
club = self.club
if club:
distance = club.getDistance(self.clubLookatSpot)
scaleFactor = distance / 2.058
club.setScale(1, scaleFactor, 1)
def startAdjustClubTask(self):
taskMgr.add(self.adjustClubTask, self.adjustClubTaskName)
def stopAdjustClubTask(self):
taskMgr.remove(self.adjustClubTaskName)
def adjustClubTask(self, task):
self.attachClub(self.avId, True)
self.adjustClub()
return task.cont
def enableControlKey(self):
self.controlKeyAllowed = True
def disableControlKey(self):
self.controlKeyAllowed = False
def sendSwingInfo(self, power, angle, sequenceNum):
self.sendUpdate('setSwingInfo', [power, angle, sequenceNum])
def startBallPlayback(self, power, angle, sequenceNum):
flyBall = self.ballModel.copyTo(NodePath())
flyBall.setScale(1.0)
flyBallBubble = self.getFlyBallBubble().instanceTo(NodePath())
flyBallBubble.reparentTo(flyBall)
flyBall.setTag('pieSequence', str(sequenceNum))
flyBall.setTag('throwerId', str(self.avId))
t = power / 100.0
t = 1.0 - t
dist = 300 - 200 * t
time = 1.5 + 0.5 * t
proj = ProjectileInterval(None,
startPos=Point3(0, 0, 0),
endPos=Point3(0, dist, 0),
duration=time)
relVel = proj.startVel
def getVelocity(root=self.root, relVel=relVel):
return render.getRelativeVector(root, relVel)
fly = Sequence(
Func(flyBall.reparentTo, render),
Func(flyBall.setPosHpr, self.root, 0, 0, 0, 0, 0, 0),
Func(base.cTrav.addCollider, flyBallBubble, self.flyBallHandler),
ProjectileInterval(flyBall, startVel=getVelocity, duration=3),
Func(flyBall.detachNode),
Func(base.cTrav.removeCollider, flyBallBubble),
Func(self.notify.debug, 'removed collider'),
Func(self.flyBallFinishedFlying, sequenceNum))
flyWithSound = Parallel(fly,
SoundInterval(self.hitBallSfx, node=self.root),
name='flyWithSound')
self.notify.debug('starting flyball track')
flyWithSound.start()
self.flyBallTracks[sequenceNum] = flyWithSound
return
def setSwingInfo(self, power, angle, sequenceNum):
av = base.cr.doId2do.get(self.avId)
self.swingInterval = Sequence()
if av:
self.stopAdjustClubTask()
self.swingInterval = Sequence(
ActorInterval(av,
'swing-putt',
startFrame=0,
endFrame=GolfGlobals.BALL_CONTACT_FRAME),
Func(self.startBallPlayback, power, angle, sequenceNum),
Func(self.ballModel.hide),
ActorInterval(av,
'swing-putt',
startFrame=GolfGlobals.BALL_CONTACT_FRAME,
endFrame=24), Func(self.ballModel.setScale, 0.1),
Func(self.ballModel.show),
LerpScaleInterval(self.ballModel, 1.0, Point3(1, 1, 1)),
Func(self.enableControlKey))
if av == localAvatar:
self.swingInterval.append(
Func(self.switchToAnimState, 'GolfPuttLoop', True))
self.swingInterval.start()
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask
| ToontownGlobals.CameraBitmask
| ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def __flyBallHit(self, entry):
print entry
def flyBallFinishedFlying(self, sequence):
if self.flyBallTracks.has_key(sequence):
del self.flyBallTracks[sequence]
def __finishFlyBallTrack(self, sequence):
if self.flyBallTracks.has_key(sequence):
flyBallTrack = self.flyBallTracks[sequence]
del self.flyBallTracks[sequence]
flyBallTrack.finish()
def flyBallFinishedSplatting(self, sequence):
if self.splatTracks.has_key(sequence):
del self.splatTracks[sequence]
def __flyBallHit(self, entry):
if not entry.hasSurfacePoint() or not entry.hasInto():
return
if not entry.getInto().isTangible():
return
sequence = int(entry.getFromNodePath().getNetTag('pieSequence'))
self.__finishFlyBallTrack(sequence)
if self.splatTracks.has_key(sequence):
splatTrack = self.splatTracks[sequence]
del self.splatTracks[sequence]
splatTrack.finish()
flyBallCode = 0
flyBallCodeStr = entry.getIntoNodePath().getNetTag('pieCode')
if flyBallCodeStr:
flyBallCode = int(flyBallCodeStr)
pos = entry.getSurfacePoint(render)
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
throwerId = int(entry.getFromNodePath().getNetTag('throwerId'))
splat = self.getFlyBallSplatInterval(pos[0], pos[1], pos[2],
flyBallCode, throwerId)
splat = Sequence(splat, Func(self.flyBallFinishedSplatting, sequence))
self.splatTracks[sequence] = splat
splat.start()
self.notify.debug(
'doId=%d into=%s flyBallCode=%d, throwerId=%d' %
(self.doId, entry.getIntoNodePath(), flyBallCode, throwerId))
if flyBallCode == ToontownGlobals.PieCodeBossCog and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
self.boss.d_ballHitBoss(10)
elif flyBallCode == ToontownGlobals.PieCodeToon and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
avatarDoId = entry.getIntoNodePath().getNetTag('avatarDoId')
if avatarDoId == '':
self.notify.warning('Toon %s has no avatarDoId tag.' %
repr(entry.getIntoNodePath()))
return
doId = int(avatarDoId)
if doId != localAvatar.doId:
pass
def getFlyBallSplatInterval(self, x, y, z, flyBallCode, throwerId):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
splatName = 'dust'
splat = BattleProps.globalPropPool.getProp(splatName)
splat.setBillboardPointWorld(2)
color = ToontownGlobals.PieCodeColors.get(flyBallCode)
if color:
splat.setColor(*color)
if flyBallCode == ToontownGlobals.PieCodeBossCog:
self.notify.debug('changing color to %s' % self.ballColor)
splat.setColor(self.ballColor)
sound = loader.loadSfx('phase_11/audio/sfx/LB_evidence_miss.ogg')
vol = 1.0
if flyBallCode == ToontownGlobals.PieCodeBossCog:
sound = loader.loadSfx('phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg')
soundIval = SoundInterval(sound, node=splat, volume=vol)
if flyBallCode == ToontownGlobals.PieCodeBossCog and localAvatar.doId == throwerId:
vol = 1.0
soundIval = SoundInterval(sound, node=localAvatar, volume=vol)
ival = Parallel(
Func(splat.reparentTo, render), Func(splat.setPos, x, y, z),
soundIval,
Sequence(ActorInterval(splat, splatName), Func(splat.detachNode)))
return ival
def setGoingToReward(self):
self.goingToReward = True
def gotBossZapped(self):
self.showExiting()
self.d_requestFree(True)
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
global carx,cary,d,cor_ans,count
self.disableMouse()
self.Truck=[0]*6
self.crate=[0]*10
self.posc=[0]*30
self.radX=[0]*60
self.radY=[0]*60
self.radZ=[0]*60
self.sX=[0]*10
self.sY=[0]*10
self.sZ=[0]*10
self.flag=[0]*10
self.ans=[0]*10
self.inst1 = addInstructions(0.89, "Correct Answer: "+str(cor_ans))
self.inst2 = addInstructions(0.95, "Time: "+str(time))
self.inst3 = addInstructions(0.84, "Waste Reamaining "+str(count/2))
#self.title = addTitle("Recycle Game By : Sandeep Sharma")
p = 0
file = open("ans.txt")
for line in file:
#for p in range(30):
#print line
line = line.split()
self.ans[p] = str(line[0])
p=p+1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
p = 0
file = open("sample.txt")
for line in file:
#for p in range(30):
line = line[0:len(line)-1]
#print line
self.posc[p] = int(line)
p=p+1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
p=0
file = open("scale.txt")
for line in file:
#for p in range(30):
line = line.split()
#print line
self.sX[p] = float(line[0])
self.sY[p] = float(line[1])
self.sZ[p] = float(line[2])
#print self.radY[p]
p=p+1
p = 0
file = open("rad.txt")
for line in file:
#for p in range(30):
line = line.split()
#print line
self.radX[p] = float(line[0])
self.radY[p] = float(line[1])
self.radZ[p] = float(line[2])
#print self.radY[p]
p=p+1
# self.posc[p]= int(line)
#print self.posc[p]
#break
file.close()
self.CornField=self.loader.loadModel("cornfield")
self.CornField.reparentTo(self.render)
self.CornField.setScale(1000,1000,0)
self.CornField.setPos(0,0,-8)
self.WM=self.loader.loadModel("WM/Windmill")
self.WM.reparentTo(self.render)
self.WM.setScale(2,2,2)
self.WM.setPos(354,131,0)
self.WM.setHpr(180,0,0)
self.F1=self.loader.loadModel("Forest/Forest")
self.F1.reparentTo(self.render)
self.F1.setScale(0.8,0.5,0.5)
self.F1.setPos(-338,-164,0)
self.F1.setHpr(90,0,0)
self.F2=self.loader.loadModel("Forest/Forest")
self.F2.reparentTo(self.render)
self.F2.setScale(0.8,0.5,0.5)
self.F2.setPos(366,-189,0)
self.F2.setHpr(90,0,0)
self.castle=self.loader.loadModel("castle")
self.castle.reparentTo(self.render)
self.castle.setScale(0.6,0.8,0.5)
self.castle.setPos(-97,-200,0)
self.castle.setHpr(90,0,0)
#print self.castle
self.church=self.loader.loadModel("church/Church")
self.church.reparentTo(self.render)
self.church.setScale(2.5,2.5,1)
self.church.setPos(90,-200,0)
self.church.setHpr(180,0,0)
self.Temple=self.loader.loadModel("Temple/TempleFort")
self.Temple.reparentTo(self.render)
self.Temple.setScale(0.06,0.1,0.18)
self.Temple.setPos(210,-109,0)
self.house=self.loader.loadModel("BuildingCluster3")
self.house.reparentTo(self.render)
self.house.setScale(1.5,1.5,1)
self.house.setPos(208,86,0)
self.CityHall=self.loader.loadModel("cityhall/CityHall")
self.CityHall.reparentTo(self.render)
self.CityHall.setScale(1.5,1.5,1.5)
self.CityHall.setPos(-188,-84,0)
self.CityHall.setHpr(90,0,0)
self.statue=self.loader.loadModel("statue/statue")
self.statue.reparentTo(self.render)
self.statue.setScale(4.5,4.5,3.5)
self.statue.setPos(-191,105,0)
self.statue.setHpr(-90,0,0)
self.FarmHouse=self.loader.loadModel("farmhouse/FarmHouse")
self.FarmHouse.reparentTo(self.render)
self.FarmHouse.setScale(2.8,3.5,2.5)
self.FarmHouse.setPos(-66,209,0)
self.Fence1=self.loader.loadModel("fence/fence")
self.Fence1.reparentTo(self.render)
self.Fence1.setScale(70,1,2)
self.Fence1.setPos(0,-418,0)
self.Fence2=self.loader.loadModel("fence/fence")
self.Fence2.reparentTo(self.render)
self.Fence2.setScale(70,1,2)
self.Fence2.setPos(0,418,0)
self.Fence3=self.loader.loadModel("fence/fence")
self.Fence3.reparentTo(self.render)
self.Fence3.setScale(70,1,2)
self.Fence3.setPos(-418,0,0)
self.Fence3.setHpr(90,0,0)
self.Fence4=self.loader.loadModel("fence/fence")
self.Fence4.reparentTo(self.render)
self.Fence4.setScale(70,1,2)
self.Fence4.setPos(418,0,0)
self.Fence4.setHpr(90,0,0)
self.CityTerrain=self.loader.loadModel("CityTerrain/CityTerrain")
self.CityTerrain.reparentTo(self.render)
self.CityTerrain.setScale(0.5,0.5,0.5)
self.CityTerrain.setPos(0,0,0)
self.BeachTerrain=self.loader.loadModel("BeachTerrain/BeachTerrain")
self.BeachTerrain.reparentTo(self.render)
self.BeachTerrain.setScale(0.5,0.5,0.5)
self.BeachTerrain.setPos(200,750,0)
self.BeachTerrain.setHpr(90,0,0)
self.school=self.loader.loadModel("school/school")
self.school.reparentTo(self.render)
self.school.setScale(0.056,0.07,0.05)
self.school.setPos(-162,-348,0)
self.school.setHpr(90,0,0)
self.car = Actor("bvw-f2004--jeep/jeep",{"walk": "bvw-f2004--jeep/jeep-start"})
self.car.setScale(0.5, 0.5, 0.5)
self.car.reparentTo(self.render)
self.car.setPos(carx,cary,-2)
self.car.setHpr(180,0,0)
#print self.car
for l in range(10):
self.crate[l] = self.loader.loadModel("model"+str(l+1)+"/crate"+str(l+1)+".egg")
self.crate[l].setScale(self.sX[l], self.sY[l], self.sZ[l])
self.crate[l].reparentTo(self.render)
self.crate[l].setPos(self.posc[3*l],self.posc[3*l + 1],2)
self.crate[l].setHpr(0,0,0)
#self.car.loop("walk")
#self.car.reparentTo(self.render)
#self.car.setScale(2,2,2)
#self.car.setPos(carx,cary,-2)
#self.car.setHpr(0,0,0)
self.museum = self.loader.loadModel("Museum/Museum")
self.museum.reparentTo(self.render)
self.museum.setScale(1,2,1.5)
self.museum.setPos(100,200,0)
self.museum.setHpr(180,0,0)
self.PalmTree = self.loader.loadModel("PalmTree/palmtree")
self.PalmTree.reparentTo(self.render)
self.PalmTree.setScale(2,2,3.5)
self.PalmTree.setPos(175,200,0)
self.PalmTree.setHpr(0,0,0)
self.stadium = self.loader.loadModel("Stadium/stadium")
self.stadium.reparentTo(self.render)
self.stadium.setScale(0.5,0.5,0.5)
self.stadium.setPos(13,0,0)
self.stadium.setHpr(0,0,0)
self.Junkyard = self.loader.loadModel("Junkyard")
self.Junkyard.reparentTo(self.render)
self.Junkyard.setScale(0.2,0.4,0.3)
self.Junkyard.setPos(150,-650/2 - 25,0)
self.Junkyard.setHpr(90,0,0)
self.BB1 = self.loader.loadModel("BuildingCluster1")
self.BB1.reparentTo(self.render)
self.BB1.setScale(0.5,0.5,1)
self.BB1.setPos(-100 - 10,650/2 + 20,0)
self.BB1.setHpr(270,0,0)
self.BB2 = self.loader.loadModel("BB2/BuildingCluster2")
self.BB2.reparentTo(self.render)
self.BB2.setScale(0.5,0.5,1)
self.BB2.setPos(-60 - 10,650/2 + 20,0)
self.BB2.setHpr(270,0,0)
self.BB3 = self.loader.loadModel("BB3/BuildingCluster3")
self.BB3.reparentTo(self.render)
self.BB3.setScale(0.5,0.5,1)
self.BB3.setPos(-140 - 10,650/2 + 20,0)
self.BB3.setHpr(270,0,0)
self.BB4 = self.loader.loadModel("BB4/BuildingCluster4")
self.BB4.reparentTo(self.render)
self.BB4.setScale(0.5,0.5,1)
self.BB4.setPos(-25 - 10,650/2 + 20,0)
self.BB4.setHpr(270,0,0)
self.BB5 = self.loader.loadModel("BB5/BuildingCluster5")
self.BB5.reparentTo(self.render)
self.BB5.setScale(0.5,0.5,1)
self.BB5.setPos(-190 - 10,650/2 + 20,0)
self.BB5.setHpr(270,0,0)
self.BS = self.loader.loadModel("BS/blue_sky_sphere")
self.BS.reparentTo(self.render)
self.BS.setScale(1,1,1)
self.BS.setPos(-180,0,0)
self.flagMain = self.loader.loadModel("Flag/flag")
self.flagMain.setScale(0.3,0.3,0.3)
self.flagMain.reparentTo(self.render)
self.flagMain.setPos(carx-20,cary,10)
print self.flagMain
for i in range (6):
self.Truck[i] = self.loader.loadModel("bvw-f2004--fireengine/fireengine")
self.Truck[i].reparentTo(self.render)
self.Truck[i].setScale(2,2,2)
##self.Truck[i].setPos(180,0,0)
#Create the four lerp intervals needed to walk back and forth
self.setTruck()
#self.City = self.loader.loadModel("City/course2")
#self.City.reparentTo(self.render)
#self.City.setScale(2.5,2.5,2.5)
#self.City.setPos(500,0,0)
self.accept('arrow_down',self.moved,[0])
self.accept('arrow_up',self.move,[0])
self.accept("arrow_left",self.change_dc,[0])
self.accept("arrow_right",self.change_da,[0])
self.accept('arrow_down-up',self.moved,[2])
self.accept('arrow_up-up',self.move,[2])
#self.accept("arrow_left-up",self.change_dc,[2])
#self.accept("arrow_right-up",self.change_da,[2])
self.accept('arrow_down-repeat',self.moved,[1])
self.accept('arrow_up-repeat',self.move,[1])
self.accept("arrow_left-repeat",self.change_dc,[1])
self.accept("arrow_right-repeat",self.change_da,[1])
base.cTrav = CollisionTraverser()
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
self.collCount = 0
sColl = self.initCollisionSphere(self.car,1,1,1, True)
base.cTrav.addCollider(sColl[0], self.collHandEvent)
self.accept('into-' + sColl[1] , self.collide)
#self.accept('outof-' + sColl[1], self.collide4)
i=0
for child in render.getChildren():
if child != self.CornField and child != camera and child != self.CityTerrain and child!= self.BeachTerrain and child != self.BS and child != self.Fence1 and child != self.Fence2 and child != self.Fence3 and child != self.Fence4:
#print child
tColl = self.initCollisionSphere(child,self.radX[i],self.radY[i],self.radZ[i], True)
base.cTrav.addCollider(tColl[0], self.collHandEvent)
#print i
i=i+1
# Accept the events sent by the collisions.
self.accept('into-' + tColl[1] , self.collide)
for l in range(10):
self.flag[l] = self.loader.loadModel("Flag/flag")
self.flag[l].setScale(0.3,0.3,0.3)
self.flag[l].reparentTo(self.render)
self.flag[l].setPos(self.posc[3*l],self.posc[3*l + 1],10)
# self.accept( 'into-' + sColl[1], self.collide)
#self.accept('outof-' + tColl[1], self.collide2)
# print carx,cary
# cs = CollisionSphere(0, 0, 0, 10)
# fromObject = self.car.attachNewNode(CollisionNode('cnode'))
# fromObject.node().addSolid(cs)
# fromObject.show()
# pusher = CollisionHandlerPusher()
# pusher.addCollider(fromObject, self.car)
# base.cTrav = CollisionTraverser()
# base.cTrav.addCollider(fromObject, pusher)
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
def collide(self,collEntry):
global carx,cary,car_def,a,Num,count
#print "Collide"
#print collEntry.getFromNodePath().getParent()
#for objectc in collEntry:
for l in range(10):
#print collEntry.getFromNodePath().getParent()
if collEntry.getIntoNodePath().getParent() == self.crate[l] :
collEntry.getIntoNodePath().getParent().remove()
#print "Baba"
Num = l
count = count - 1
self.flag[l].hide()
self.Game_Point()
if str(collEntry.getIntoNodePath().getParent()) == "render/flag.egg" and count == 0 and str(collEntry.getFromNodePath().getParent()) == "render/jeepNman_loop_baked":
#print "here"
self.GameOver()
if str(collEntry.getIntoNodePath().getParent()) == "render/jeepNman_loop_baked" or str(collEntry.getFromNodePath().getParent()) == "render/jeepNman_loop_baked":
if a==0:
if self.car.getH() == 45:
carx = carx + car_def
cary = cary - car_def
if self.car.getH() == 90:
carx = carx + car_def
if self.car.getH() == 135:
carx = carx + car_def
cary = cary + car_def
if self.car.getH() == 180:
cary=cary + car_def
if self.car.getH() == 225:
carx = carx - car_def
cary = cary + car_def
if self.car.getH() == 270:
carx = carx - car_def
if self.car.getH() == 315:
carx =carx - car_def
cary= cary - car_def
if self.car.getH() == 0:
cary = cary - car_def
if a==1:
car_def= -1*car_def
if self.car.getH() == 45:
carx = carx + car_def
cary = cary - car_def
if self.car.getH() == 90:
carx = carx + car_def
if self.car.getH() == 135:
carx = carx + car_def
cary = cary + car_def
if self.car.getH() == 180:
cary=cary + car_def
if self.car.getH() == 225:
carx = carx - car_def
cary = cary + car_def
if self.car.getH() == 270:
carx = carx - car_def
if self.car.getH() == 315:
carx =carx - car_def
cary= cary - car_def
if self.car.getH() == 0:
cary = cary - car_def
car_def= -1*car_def
# def collide2(self,collEntry):
#
# def collide3(self,collEntry):
# global carx , cary
# carx=carx-2
# cary=cary-2
# def collide4(self,collEntry):
# print 4
def initCollisionSphere(self, obj,setX,setY,setZ, show=False):
# Get the size of the object for the collision sphere.
bounds = obj.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius() * 0.6
# Create a collision sphere and name it something understandable.
collSphereStr = 'CollisionHull' + str(self.collCount) + "_" + obj.getName()
self.collCount += 1
self.accept('arrow_down',self.moved,[0])
self.accept('arrow_up',self.move,[0])
cNode = CollisionNode(collSphereStr)
# cNode.setScale(3,3,3)
cNode.addSolid(CollisionSphere(center, radius))
cNodepath = obj.attachNewNode(cNode)
cNodepath.setScale(setX,setY,setZ)
#cNodepath.show()
# Return a tuple with the collision node and its corrsponding string so
# that the bitmask can be set.
return (cNodepath, collSphereStr)
def moved(self,i):
global carx,cary,camx,camy,dis,a
#print "moved"
a=1
if i ==0:
#print "Hello"
self.car.loop("walk")
if i==2:
self.car.stop("walk")
#print "hello",self.car.getH()
#print base.camera.getH()
if carx> -410 and carx<410 and cary>-410 and cary<410:
if self.car.getH() == 45:
carx = carx - car_speed
cary = cary + car_speed
camx = carx - dis
camy = cary + dis
if self.car.getH() == 90:
carx = carx - car_speed
camx = carx - dis
if self.car.getH() == 135:
carx = carx - car_speed
cary = cary - car_speed
camx = carx - dis
camy = cary -dis
if self.car.getH() == 180:
cary=cary - car_speed
camy = cary - dis
if self.car.getH() == 225:
carx = carx + car_speed
cary = cary - car_speed
camx=carx + dis
camy=cary - dis
if self.car.getH() == 270:
carx = carx + car_speed
camx =carx + dis
if self.car.getH() == 315:
carx =carx +car_speed
cary= cary +car_speed
camx=carx + dis
camy =cary +dis
if self.car.getH() == 0:
cary = cary + car_speed
camy = cary + dis
else:
if carx <= -410:
carx = carx-1
if carx >= 410:
carx = carx+1
if cary <= -410:
cary = cary-1
if cary >= 410:
cary = cary+1
def move(self,i):
global carx,cary,camx,camy,dis,a
a=0
# print "move"
# print carx,cary
if i ==0:
self.car.loop("walk")
if i==2:
self.car.stop("walk")
#print "hello",self.car.getH()
#print base.camera.getH()
if carx>-410 and carx<410 and cary>-410 and cary<410:
if self.car.getH() == 45:
carx = carx + car_speed
cary = cary - car_speed
camx = carx + dis
camy = cary - dis
if self.car.getH() == 90:
carx = carx + car_speed
camx = carx + dis
if self.car.getH() == 135:
carx = carx + car_speed
cary = cary + car_speed
camx = carx + dis
camy = cary +dis
if self.car.getH() == 180:
cary=cary + car_speed
camy = cary + dis
if self.car.getH() == 225:
carx = carx - car_speed
cary = cary + car_speed
camx=carx - dis
camy=cary + dis
if self.car.getH() == 270:
carx = carx - car_speed
camx =carx - dis
if self.car.getH() == 315:
carx =carx - car_speed
cary= cary - car_speed
camx=carx - dis
camy =cary - dis
if self.car.getH() == 0:
cary = cary - car_speed
camy = cary - car_speed
else:
if carx<=-410:
carx = carx+1
if carx>=410:
carx= carx-1
if cary<=-410:
cary = cary+1
if cary>=410:
cary=cary -1
# self.car.loop("walk")
def change_dc(self,i):
global d
#if i ==0:
# print "Hello"
# self.car.loop("walk")
#if i==2:
# self.car.stop("walk")
d=d + 45
d=d % 360
def change_da(self,i):
global d
#if i ==0:
# print "Hello"
# self.car.loop("walk")
#if i==2:
# self.car.stop("walk")
d = d - 45
d=d%360
#for j in range(9):
# d=d - 5
#
# d=d % 360
# self.car.setHpr(d , 0 , 0)
# time.sleep(0.1)
#messenger.send('arrow_up-repeat')
def spinCameraTask(self, task):
global time,carx,cary,d,dis,camx,camy,count,cor_ans
time = int(task.time)
#r = d * (pi / 180.0)
#print carx,cary
if self.car.getH() == 45:
camx = carx - dis
camy = cary + dis
if self.car.getH() == 90:
camx = carx - 1.41*dis
camy = cary
if self.car.getH() == 135:
camx = carx - dis
camy = cary -dis
if self.car.getH() == 180:
camy = cary - 1.41*dis
camx =carx
if self.car.getH() == 225:
camx=carx + dis
camy=cary - dis
if self.car.getH() == 270:
camx =carx + 1.41*dis
camy=cary
if self.car.getH() == 315:
camx=carx + dis
camy =cary +dis
if self.car.getH() == 0:
camy = cary + 1.41*dis
camx=carx
if h==0:
self.inst1.destroy()
self.inst2.destroy()
self.inst3.destroy()
self.inst1 = addInstructions(0.89, "Correct Answer: "+str(cor_ans))
self.inst2 = addInstructions(0.95, "Time: "+str(time))
self.inst3 = addInstructions(0.84, "Waste Reamaining "+str(count/2))
self.car.setPos(carx,cary,0)
self.car.setHpr(d , 0 , 0)
base.camera.setPos(camx ,camy,5)
base.camera.setHpr(d + 180, 0 , 0)
#base.camera.setPos(0,0,1700)
#base.camera.setHpr(0, -90 , 0)
return Task.cont
# base.camera.setPos(0,-40,3)
# return Task.cont
def setTruck(self):
pandaPosInterval01= self.Truck[0].posInterval(11,Point3(18,138,0), startPos=Point3(21,390,0))
pandaPosInterval02= self.Truck[0].posInterval(5,Point3(140,132,0), startPos=Point3(18,138,0))
pandaPosInterval03= self.Truck[0].posInterval(10,Point3(140,-123,0), startPos=Point3(140,132,0))
pandaPosInterval04= self.Truck[0].posInterval(5,Point3(-7,-126,0), startPos=Point3(140,-123,0))
pandaPosInterval05= self.Truck[0].posInterval(11,Point3(-10,-399,0), startPos=Point3(-7,-126,0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval00= self.Truck[0].hprInterval(1,Point3(180,0,0), startHpr=Point3(0,0,0))
pandaHprInterval01= self.Truck[0].hprInterval(3,Point3(-90,0,0), startHpr=Point3(180,0,0))
pandaHprInterval02= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(-90,0,0))
pandaHprInterval03= self.Truck[0].hprInterval(3,Point3(90,0,0), startHpr=Point3(180,0,0))
pandaHprInterval04= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0))
#pandaHprInterval5= self.Truck[0].hprInterif collEntry.getIntoNodePath().getParent() == self.crate[l]:val(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace0 = Sequence(pandaHprInterval00,pandaPosInterval01, pandaHprInterval01,
pandaPosInterval02, pandaHprInterval02,pandaPosInterval03,pandaHprInterval03,pandaPosInterval04,pandaHprInterval04,pandaPosInterval05, name = "pandaPace0")
pandaPace0.loop()
pandaPosInterval11= self.Truck[1].posInterval(11,Point3(-126,14,0), startPos=Point3(-411,14,0))
pandaPosInterval12= self.Truck[1].posInterval(5,Point3(-117,145,0), startPos=Point3(-126,14,0))
pandaPosInterval13= self.Truck[1].posInterval(10,Point3(148,130,0), startPos=Point3(-117,145,0))
pandaPosInterval14= self.Truck[1].posInterval(5,Point3(145,-5,0), startPos=Point3(148,130,0))
pandaPosInterval15= self.Truck[1].posInterval(11,Point3(394,-8,0), startPos=Point3(145,-5,0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval10= self.Truck[1].hprInterval(1,Point3(-90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval11= self.Truck[1].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0))
pandaHprInterval12= self.Truck[1].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval13= self.Truck[1].hprInterval(3,Point3(180,0,0), startHpr=Point3(-90,0,0))
pandaHprInterval14= self.Truck[1].hprInterval(3,Point3(-90,0,0), startHpr=Point3(180,0,0))
#pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace1 = Sequence(pandaHprInterval10,pandaPosInterval11, pandaHprInterval11,
pandaPosInterval12, pandaHprInterval12,pandaPosInterval13,pandaHprInterval13,pandaPosInterval14,pandaHprInterval14,pandaPosInterval15, name = "pandaPace1")
pandaPace1.loop()
pandaPosInterval21= self.Truck[2].posInterval(11,Point3(-9,-144,0), startPos=Point3(-6,-358,0))
pandaPosInterval22= self.Truck[2].posInterval(5,Point3(-129,-137,0), startPos=Point3(-9,-144,0))
pandaPosInterval23= self.Truck[2].posInterval(10,Point3(-129,142,0), startPos=Point3(-129,-137,0))
pandaPosInterval24= self.Truck[2].posInterval(5,Point3(5,145,0), startPos=Point3(-129,142,0))
pandaPosInterval25= self.Truck[2].posInterval(11,Point3(20,395,0), startPos=Point3(5,145,0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval20= self.Truck[2].hprInterval(1,Point3(0,0,0), startHpr=Point3(0,0,0))
pandaHprInterval21= self.Truck[2].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval22= self.Truck[2].hprInterval(3,Point3(0,0,0), startHpr=Point3(90,0,0))
pandaHprInterval23= self.Truck[2].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval24= self.Truck[2].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0))
#pandaHprInterval5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace2 = Sequence(pandaHprInterval20,pandaPosInterval21, pandaHprInterval21,
pandaPosInterval22, pandaHprInterval22,pandaPosInterval23,pandaHprInterval23,pandaPosInterval24,pandaHprInterval24,pandaPosInterval25, name = "pandaPace2")
pandaPace2.loop()
pandaPosInterval31= self.Truck[3].posInterval(11,Point3(150,-18,0), startPos=Point3(408,-18,0))
pandaPosInterval32= self.Truck[3].posInterval(5,Point3(147,-135,0), startPos=Point3(150,-18,0))
pandaPosInterval33= self.Truck[3].posInterval(10,Point3(-120,-138,0), startPos=Point3(147,-135,0))
pandaPosInterval34= self.Truck[3].posInterval(5,Point3(-123,-6,0), startPos=Point3(-120,-138,0))
pandaPosInterval35= self.Truck[3].posInterval(11,Point3(-396,10,0), startPos=Point3(-123,-6,0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
pandaHprInterval30= self.Truck[3].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval31= self.Truck[3].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0))
pandaHprInterval32= self.Truck[3].hprInterval(3,Point3(90,0,0), startHpr=Point3(180,0,0))
pandaHprInterval33= self.Truck[3].hprInterval(3,Point3(0,0,0), startHpr=Point3(90,0,0))
pandaHprInterval34= self.Truck[3].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0))
#pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace4 = Sequence(pandaHprInterval30,pandaPosInterval31, pandaHprInterval31,
pandaPosInterval32, pandaHprInterval32,pandaPosInterval33,pandaHprInterval33,pandaPosInterval34,pandaHprInterval34,pandaPosInterval35, name = "pandaPace4")
pandaPace4.loop()
pandaPosInterval41= self.Truck[4].posInterval(12,Point3(298,-282,0), startPos=Point3(-276,-282,0))
pandaPosInterval42= self.Truck[4].posInterval(12,Point3(286,280,0), startPos=Point3(298,-282,0))
pandaPosInterval43= self.Truck[4].posInterval(12,Point3(-268,280,0), startPos=Point3(286,280,0))
pandaPosInterval44= self.Truck[4].posInterval(12,Point3(-276,-282,0), startPos=Point3(-268,280,0))
#pandaHprInterval30= self.Truck[3].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval41= self.Truck[4].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval42= self.Truck[4].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0))
pandaHprInterval43= self.Truck[4].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval44= self.Truck[4].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0))
#pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace5 = Sequence(pandaHprInterval41,pandaPosInterval41, pandaHprInterval42,
pandaPosInterval42, pandaHprInterval43,pandaPosInterval43,pandaHprInterval44,pandaPosInterval44, name = "pandaPace5")
pandaPace5.loop()
pandaPosInterval51= self.Truck[5].posInterval(12,Point3(-268,280,0), startPos=Point3(286,280,0))
pandaPosInterval52= self.Truck[5].posInterval(12,Point3(-276,-282,0), startPos=Point3(-268,280,0))
pandaPosInterval53= self.Truck[5].posInterval(12,Point3(298,-282,0), startPos=Point3(-276,-282,0))
pandaPosInterval54= self.Truck[5].posInterval(12,Point3(286,280,0), startPos=Point3(298,-282,0))
#pandaPosInterval55= self.Truck[5].posInterval(13,Point3(-396,10,0), startPos=Point3(-123,-6,0))
#pandaPosInterval6=self.Truck[0].posInterval(1,Point3(21,390,0),startPos=Point3(-10,-399,0)
#pandaHprInterval50= self.Truck[5].hprInterval(1,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval51= self.Truck[5].hprInterval(3,Point3(90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval52= self.Truck[5].hprInterval(3,Point3(180,0,0), startHpr=Point3(90,0,0))
pandaHprInterval53= self.Truck[5].hprInterval(3,Point3(-90,0,0), startHpr=Point3(0,0,0))
pandaHprInterval54= self.Truck[5].hprInterval(3,Point3(0,0,0), startHpr=Point3(-90,0,0))
#pandaHprInterva5= self.Truck[0].hprInterval(3,Point3(180,0,0), startHpr=Point3(0,0,0))
#Create and play the sequence that coordinates the intervals
pandaPace6 = Sequence(pandaHprInterval51,pandaPosInterval51, pandaHprInterval52,
pandaPosInterval52, pandaHprInterval53,pandaPosInterval53,pandaHprInterval54,pandaPosInterval54, name = "pandaPace6")
pandaPace6.loop()
def Game_Point(self):
self.ignore("arrow_down")
self.ignore("arrow_up")
self.ignore("arrow_down-repeat")
self.ignore("arrow_up-repeat")
#self.text1 = addInstructions(0.5,"Is this Recyclable")
self.text1 = TextNode('t1')
self.text1.setText("is This Recyclable")
self.text1.setTextColor(0,0,0,1)
self.textNodePath1 = aspect2d.attachNewNode(self.text1)
self.textNodePath1.setScale(0.07)
self.textNodePath1.setPos(-0.1,-0.1,0.1)
#text1.setTextColor(1,1,1)
self.text1.setFrameColor(1, 0, 0, 1)
self.text1.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
self.text2 = TextNode('t2')
self.text2.setText("Y/N")
self.text2.setTextColor(0,0,0,1)
self.textNodePath2 = aspect2d.attachNewNode(self.text2)
self.textNodePath2.setScale(0.07)
self.textNodePath2.setPos(0,0,0)
#textNodePath2.setTextColor(1,1,1)
self.text2.setFrameColor(1, 0, 0, 1)
self.text2.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
self.accept('y',self.answer,[0])
self.accept('n',self.answer,[1])
def answer(self,n):
global Num,cor_ans
#print self.ans[Num]
self.accept('arrow_down',self.moved,[0])
self.accept('arrow_up',self.move,[0])
self.accept('arrow_down-repeat',self.moved,[1])
self.accept('arrow_up-repeat',self.move,[1])
aspect2d.getChildren().detach()
if n == 0:
if self.ans[Num] == 'Y':
cor_ans = cor_ans + 1
if n == 1:
if self.ans[Num] == 'N':
#print "Correct"
cor_ans = cor_ans + 1
self.ignore('y')
self.ignore('n')
#print "Hello"
def GameOver(self):
global cor_ans,time,h
h=1
#print time
for x in self.render.getChildren():
x.detachNode()
self.inst1.destroy()
self.inst2.destroy()
self.inst3.destroy()
self.text3 = TextNode('t1')
self.text3.setText("Game Over ")
self.text3.setTextColor(1,0,0,1)
self.textNodePath3 = aspect2d.attachNewNode(self.text3)
self.textNodePath3.setScale(0.1)
self.textNodePath3.setPos(-0.1,-0.1,0.2)
#text1.setTextColor(1,1,1)
#self.text3.setFrameColor(1, 0, 0, 1)
#self.text3.setFrameAsMargin(0.2, 0.2, 0.1, 0.1)
self.text5 = TextNode('t1')
self.text5.setText("Time Taken: "+ str(time))
self.text5.setTextColor(1,0,0,1)
self.textNodePath5 = aspect2d.attachNewNode(self.text5)
self.textNodePath5.setScale(0.1)
self.textNodePath5.setPos(-0.1,-0.1,0)
self.text6 = TextNode('t1')
self.text6.setText("correct answer: " + str(cor_ans))
self.text6.setTextColor(1,0,0,1)
self.textNodePath6 = aspect2d.attachNewNode(self.text6)
self.textNodePath6.setScale(0.1)
self.textNodePath6.setPos(-0.1,-0.1,-0.2)
self.text4 = TextNode('t2')
self.text4.setText("Score: " + str(5000/time + (cor_ans * 10)))
self.text4.setTextColor(1,0,0,1)
self.textNodePath4 = aspect2d.attachNewNode(self.text4)
self.textNodePath4.setScale(0.1)
self.textNodePath4.setPos(-0.1,-0.1,-0.4)
class CollisionManager:
def __init__(self):
self.line_dir = NodePath()
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays","mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%(""rays"")fh%(""type"")ih")
self.model = loader.loadModel("../models/chest.egg")
self.model_node = NodePath("sdfafd")
self.model.reparentTo(self.model_node)
self.model_node.reparentTo(render)
#
# self.text_node = TextNode("battle_text")
# self.text_node.setText("TEXTYTEXTYTEXTTEXT")
# self.text_node_path = render.attachNewNode(self.text_node)
# self.text_node_path.reparentTo(render)
# self.text_node_path.setPos(0,0,4)
# self.text_node_path.setHpr(0,0,0)
# self.text_node_path.setScale(1)
# #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha)
# self.text_node.setTextColor((1,1,1,1))
# self.text_node.setAlign(TextNode.ALeft)
self.placement_ghost = EditorObjects.PlacementGhost(0,"tower",base.object_scale)
z=0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
self.input_init()
self.pickable=None
def input_init(self):
self.DO=DirectObject()
self.DO.accept('mouse1', self.mouse_click, ["1-down"])
self.DO.accept('mouse1-up', self.mouse_click, ["1-up"])
self.DO.accept('mouse3', self.mouse_click, ["3-down"])
self.DO.accept('0', self.placement_ghost.change_player, [0])
self.DO.accept('1', self.placement_ghost.change_player, [1])
self.DO.accept('2', self.placement_ghost.change_player, [2])
self.DO.accept('a', self.placement_ghost.change_type, ["army"])
self.DO.accept('t', self.placement_ghost.change_type, ["tower"])
self.DO.accept('control-s', base.xml_manager.save)
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
def col_against_object(self,entry):
if entry.getIntoNodePath().getParent() != self.pickable:
np_from=entry.getFromNodePath()
np_into=entry.getIntoNodePath()
self.selected_type = np_into.getTag("type")
self.pickable = np_into.getParent()
def col_in_object(self,entry):
if base.state == "selecting":
np_into=entry.getIntoNodePath()
np_into.getParent().setColor(0.5,0.5,0.5,1)
def col_out_object(self,entry):
np_into=entry.getIntoNodePath()
try:
np_into.getParent().clearColor()
except:
print "ERROR CLEARING COLOUR"
def get_mouse_plane_pos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(self.pos3d,
render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
#print "Mouse ray intersects ground plane at ", self.pos3d
self.model_node.setPos(render, self.pos3d)
self.placement_ghost.set_position(self.pos3d[0],self.pos3d[1])
return task.again
def ray_update(self,task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(),mpos.getY())
return task.cont
def task_mouse_place(self,task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.placing_object = True
self.place_pos = (self.anchor_x,self.anchor_y)
self.line_dir.remove()
ls = LineSegs()
ls.move_to(self.anchor_x,self.anchor_y,1)
ls.draw_to(self.model.getX(),self.model.getY(),1)
node = ls.create()
angle1 = math.atan2(self.anchor_y - self.anchor_y,self.anchor_x - self.anchor_x+50)
angle2 = math.atan2(self.anchor_y - self.model.getY(),self.anchor_x - self.model.getY());
final_angle = angle1-angle2;
self.model.setHpr(final_angle,0,0)
self.line_dir = NodePath(node)
self.line_dir.reparentTo(render)
return task.again
else:
self.line_dir.hide()
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
return task.done
def task_mouse_press_check(self,task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
#if self.multi_select == True:
self.anchor_x,self.anchor_y = self.model.getX(),self.model.getY()
taskMgr.add(self.task_mouse_place, "multibox")
return task.done
return task.again
def mouse_click(self,status):
print base.state
if status == "1-down":
if base.state == "placement":
if self.placement_ghost.get_type() == "tower":
obj = self.placement_ghost.place("tower",self.model.getX(),self.model.getY())
elif self.placement_ghost.get_type() == "army":
obj = self.placement_ghost.place("army",self.model.getX(),self.model.getY())
base.details_box.set_object(obj)
base.change_state("modifying")
elif base.state == "moving":
obj = base.details_box.get_object()
obj.set_position(self.pos3d[0],self.pos3d[1])
base.change_state("modifying")
elif base.state == "selecting" and self.pickable != None:
obj = base.get_obj_from_node(self.pickable)
base.details_box.set_object(obj,"selecting")
base.change_state("modifying")
elif status == "1-up":
print "Mouse",status
elif status == "3-down":
if base.state == "placement":
base.change_state("selecting")
elif base.state == "selecting":
base.change_state("placement")
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay
from pandaImports import DirectObject
from tower import *
'''This file handles all the collision events
of our game
'''
#base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav=CollisionTraverser()
#collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
#"In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern('%fn-into-%in')
#"Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern('%fn-again-%in')
#"Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern('%fn-out-%in')
#self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0,0,0]
#self.addCollider(mousePicking.pickerNP)
#self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
class FreeBLiTZ(ShowBase):
def __init__(self):
from pandac.PandaModules import CollisionHandlerFloor, CollisionHandlerPusher, CollisionHandlerEvent, CollisionTraverser
from pandac.PandaModules import DirectionalLight, AmbientLight, VBase4
ShowBase.__init__(self)
self.sky = self.loader.loadModel('models/sky-sphere')
self.sky.reparentTo(self.render)
self.stage = self.loader.loadModel('models/test-collide')
self.stage.reparentTo(self.render)
self.floor = self.stage.findAllMatches('**/=CollideType=floor')
self.floor.setCollideMask(FLOOR_MASK)
self.obstacles = self.stage.findAllMatches('**/=CollideType=obstacle')
if self.obstacles:
self.obstacles.setCollideMask(OBSTACLE_MASK)
self.zones = self.stage.findAllMatches('**/=CollideType=zone')
if self.zones:
self.zones.setCollideMask(ZONE_MASK)
self.create_stanchions()
# Character rig, which allows camera to follow character
self.char_rig = self.stage.attachNewNode('char_rig')
self.active_char = Character('mainchar', self.char_rig)
self.cam.reparentTo(self.char_rig)
self.cam.setPos(0.5, -3, 1.5)
self.cam.lookAt(0.5, 0, 1.5)
self.light = DirectionalLight('dlight')
self.light.setColor(VBase4(0.3, 0.28, 0.26, 1.0))
self.lightNP = self.stage.attachNewNode(self.light)
self.lightNP.setHpr(-75, -45, 0)
self.stage.setLight(self.lightNP)
self.amblight = AmbientLight('amblight')
self.amblight.setColor(VBase4(0.7, 0.68, 0.66, 1.0))
self.amblightNP = self.stage.attachNewNode(self.amblight)
self.stage.setLight(self.amblightNP)
self.accept('w', self.active_char.begin_forward)
self.accept('a', self.active_char.begin_left)
self.accept('s', self.active_char.begin_backward)
self.accept('d', self.active_char.begin_right)
self.accept('w-up', self.active_char.end_forward)
self.accept('a-up', self.active_char.end_left)
self.accept('s-up', self.active_char.end_backward)
self.accept('d-up', self.active_char.end_right)
self.taskMgr.add(self.active_char.MoveTask, 'MoveTask')
self.look = False
self.prev_pos = None
self.accept('mouse2', self.begin_look)
self.accept('mouse2-up', self.end_look)
self.accept('mouse3', self.active_char.begin_spin)
self.accept('mouse3-up', self.active_char.end_spin)
self.taskMgr.add(self.MouseTask, 'MouseTask')
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(self.active_char.actor_from_floor,
self.char_rig)
self.wall_handler = CollisionHandlerPusher()
self.wall_handler.addCollider(self.active_char.actor_from_obstacle,
self.char_rig)
self.zone_handler = CollisionHandlerEvent()
self.zone_handler.addInPattern('%fn-into')
self.zone_handler.addOutPattern('%fn-out')
def foo(entry):
print 'You are in the zone'
def bar(entry):
print 'You are not in the zone'
self.accept('blockchar_zone-into', foo)
self.accept('blockchar_zone-out', bar)
self.cTrav = CollisionTraverser('main traverser')
self.cTrav.setRespectPrevTransform(True)
self.cTrav.addCollider(self.active_char.actor_from_floor,
self.floor_handler)
self.cTrav.addCollider(self.active_char.actor_from_obstacle,
self.wall_handler)
self.cTrav.addCollider(self.active_char.actor_from_zone,
self.zone_handler)
#self.cTrav.showCollisions(self.stage)
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 begin_look(self):
self.look = True
def end_look(self):
self.look = False
self.prev_pos = None
def MouseTask(self, task):
if self.mouseWatcherNode.hasMouse():
(x, y) = self.mouseWatcherNode.getMouse()
if self.prev_pos:
if self.look or self.active_char.spinning:
h_diff = (x - self.prev_pos[0]) * 180
p_diff = (y - self.prev_pos[1]) * 90
new_h = clamp_deg_sign(self.char_rig.getH() - h_diff)
self.char_rig.setH(new_h)
self.cam.setP(self.cam.getP() + p_diff)
self.active_char.spin(new_h)
self.prev_pos = (x, y)
return task.cont
from pandac.PandaModules import CollisionHandlerEvent, CollisionNode, CollisionTraverser, CollisionRay
from pandaImports import DirectObject
from tower import *
'''This file handles all the collision events
of our game
'''
#base.cTrav maintains a list of colliders of all solid objects in the world to check collisions (runs every frame)
base.cTrav = CollisionTraverser()
#collisionHandler specifies what to do when a collision event is detected
collisionHandler = CollisionHandlerEvent()
#"In" event: when there is a collision in the current frame, but it didn't in the previous frame
collisionHandler.addInPattern('%fn-into-%in')
#"Again" event: when there is a collision in the current frame, the same that happened in the previous frame
collisionHandler.addAgainPattern('%fn-again-%in')
#"Out" event: when there isn't a collision in the current frame, but there was in the previous frame
collisionHandler.addOutPattern('%fn-out-%in')
#self.collision3DPoint is the point where the collision occurs
collision3DPoint = [0, 0, 0]
#self.addCollider(mousePicking.pickerNP)
#self.addCollider(player.getTower(-1).troop.troopModel.troopColliderNP)
DO = DirectObject()
def addCollisionEventAgain(fromName, intoName, function, extraArgs=[]):
#Let's manage now the collision events:
DO.accept(fromName + "-again-" + intoName, function, extraArgs)
class World(DirectObject):
def __init__(self):
# Initialize the traverser.
base.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern("into-%in")
self.collHandEvent.addOutPattern("outof-%in")
# Make a variable to store the unique collision string count.
self.collCount = 0
# Load a model. Reparent it to the camera so we can move it.
s = loader.loadModel("smiley")
s.reparentTo(camera)
s.setPos(0, 25, 0)
# Setup a collision solid for this model.
sColl = self.initCollisionSphere(s, True)
# Add this object to the traverser.
base.cTrav.addCollider(sColl[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept("into-" + sColl[1], self.collide3)
self.accept("outof-" + sColl[1], self.collide4)
print(sColl[1])
# Load another model.
t = loader.loadModel("smiley")
t.reparentTo(render)
t.setPos(5, 25, 0)
# Setup a collision solid for this model.
tColl = self.initCollisionSphere(t, True)
# Add this object to the traverser.
base.cTrav.addCollider(tColl[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept("into-" + tColl[1], self.collide)
self.accept("outof-" + tColl[1], self.collide2)
print(tColl[1])
print("WERT")
def collide(self, collEntry):
print("WERT: object has collided into another object")
Sequence(
Func(collEntry.getFromNodePath().getParent().setColor, VBase4(1, 0, 0, 1)),
Wait(0.2),
Func(collEntry.getFromNodePath().getParent().setColor, VBase4(0, 1, 0, 1)),
Wait(0.2),
Func(collEntry.getFromNodePath().getParent().setColor, VBase4(1, 1, 1, 1)),
).start()
def collide2(self, collEntry):
print("WERT.: object is no longer colliding with another object")
def collide3(self, collEntry):
print("WERT2: object has collided into another object")
def collide4(self, collEntry):
print("WERT2: object is no longer colliding with another object")
def initCollisionSphere(self, obj, show=False):
# Get the size of the object for the collision sphere.
bounds = obj.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius() * 1.1
# Create a collision sphere and name it something understandable.
collSphereStr = "CollisionHull" + str(self.collCount) + "_" + obj.getName()
self.collCount += 1
cNode = CollisionNode(collSphereStr)
cNode.addSolid(CollisionSphere(center, radius))
cNodepath = obj.attachNewNode(cNode)
if show:
cNodepath.show()
# Return a tuple with the collision node and its corrsponding string so
# that the bitmask can be set.
return (cNodepath, collSphereStr)
class World(DirectObject):
def __init__(self):
# Initialize the traverser.
base.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.collHandEvent.addOutPattern('outof-%in')
# Make a variable to store the unique collision string count.
self.collCount = 0
# Load a model. Reparent it to the camera so we can move it.
s = loader.loadModel('smiley')
s.reparentTo(camera)
s.setPos(0, 25, 0)
# Setup a collision solid for this model.
sColl = self.initCollisionSphere(s, True)
# Add this object to the traverser.
base.cTrav.addCollider(sColl[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept('into-' + sColl[1], self.collide3)
self.accept('outof-' + sColl[1], self.collide4)
print(sColl[1])
# Load another model.
t = loader.loadModel('smiley')
t.reparentTo(render)
t.setPos(5, 25, 0)
# Setup a collision solid for this model.
tColl = self.initCollisionSphere(t, True)
# Add this object to the traverser.
base.cTrav.addCollider(tColl[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept('into-' + tColl[1], self.collide)
self.accept('outof-' + tColl[1], self.collide2)
print(tColl[1])
print("WERT")
def collide(self, collEntry):
print("WERT: object has collided into another object")
Sequence(
Func(collEntry.getFromNodePath().getParent().setColor,
VBase4(1, 0, 0, 1)), Wait(0.2),
Func(collEntry.getFromNodePath().getParent().setColor,
VBase4(0, 1, 0, 1)), Wait(0.2),
Func(collEntry.getFromNodePath().getParent().setColor,
VBase4(1, 1, 1, 1))).start()
def collide2(self, collEntry):
print("WERT.: object is no longer colliding with another object")
def collide3(self, collEntry):
print("WERT2: object has collided into another object")
def collide4(self, collEntry):
print("WERT2: object is no longer colliding with another object")
def initCollisionSphere(self, obj, show=False):
# Get the size of the object for the collision sphere.
bounds = obj.getChild(0).getBounds()
center = bounds.getCenter()
radius = bounds.getRadius() * 1.1
# Create a collision sphere and name it something understandable.
collSphereStr = 'CollisionHull' + str(
self.collCount) + "_" + obj.getName()
self.collCount += 1
cNode = CollisionNode(collSphereStr)
cNode.addSolid(CollisionSphere(center, radius))
cNodepath = obj.attachNewNode(cNode)
if show:
cNodepath.show()
# Return a tuple with the collision node and its corrsponding string so
# that the bitmask can be set.
return (cNodepath, collSphereStr)
#step 3) make a Geom object to hold the primitives
squareGeom=Geom(vdata)
squareGeom.addPrimitive(tris)
#now put squareGeom in a GeomNode. You can now position your geometry in the scene graph.
squareGN=GeomNode("square")
squareGN.addGeom(squareGeom)
terrainNode = NodePath("terrNode")
terrainNode.reparentTo(render)
terrainNode.attachNewNode(squareGN)
terrainNode.setX(-width/2)
texGrass = loader.loadTexture("textures/envir-ground.jpg")
terrainNode.setTexture(texGrass)
cHandler.addInPattern("%(rays)ft-into-%(building)it")
cHandler.addOutPattern("%(rays)ft-out-%(building)it")
cHandler.addAgainPattern("ray_again_all%(""rays"")fh%(""building"")ih")
DO=DirectObject()
DO.accept('ray1-into-buildPlayer1', collideInBuilding)
DO.accept('ray1-out-buildPlayer1', collideOutBuilding)
DO.accept('ray_again_all', collideAgainstBuilds)
pickingEnabledOject=None
DO.accept('mouse1', mouseClick, ["down"])
DO.accept('mouse1-up', mouseClick, ["up"])
class CollisionManager:
def __init__(self):
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
self.selected = -1
self.selected_node = None
self.selecteds = []
self.multi_select = False
self.multi_selecting = False
self.select_box = NodePath()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.DO = DirectObject()
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-battle', self.col_in_object)
self.DO.accept('mray-out-battle', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
if base.client == False:
self.col_handler.addInPattern("%(player)ft-into-%(player)it")
self.col_handler.addInPattern("%(type)ft-into-%(type)it")
self.DO.accept('army-into-battle', self.col_army_against_battle)
self.DO.accept('army-into-tower', self.col_army_against_tower)
self.DO.accept('1-into-2', self.col_p1_into_p2)
self.pickable = None
self.DO.accept('mouse1', self.mouse_click, ["down"])
self.DO.accept('mouse1-up', self.mouse_click, ["up"])
self.DO.accept('mouse3-up', self.mouse_order)
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.task_select_check, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
self.model = loader.loadModel("models/chest.egg")
self.model.reparentTo(render)
self.model.hide()
cm = CardMaker("blah")
cm.setFrame(-100, 100, -100, 100)
pnode = render.attachNewNode(cm.generate()) #.lookAt(0, 0, -1)
pnode.hide()
def col_army_against_battle(self, entry):
print "Army Joins!"
#base.net_manager.battle_join(bat,army)
army = entry.getFromNodePath()
a_id = int(army.getParent().getTag("id"))
a = base.armies[a_id]
if a.state == "normal":
battle = entry.getIntoNodePath()
b_id = int(battle.getParent().getTag("id"))
if base.single_player == False:
base.net_manager.server_messager(
"battle_armyadd",
[b_id, a_id,
a.node_path.getX(),
a.node_path.getY()])
a = base.armies[a_id]
b = base.battles[b_id]
b.add_army(a)
def col_p1_into_p2(self, entry):
if entry.getFromNodePath().getTag(
"state") == "normal" and entry.getIntoNodePath().getTag(
"state") == "normal" and entry.getIntoNodePath().getTag(
"type") == "army" and entry.getFromNodePath().getTag(
"type") == "army":
#base.net_manager.battle_start(a1,a2)
army1 = entry.getFromNodePath()
army2 = entry.getIntoNodePath()
a1_id = int(army1.getParent().getTag("id"))
a2_id = int(army2.getParent().getTag("id"))
a1 = base.armies[a1_id]
a2 = base.armies[a2_id]
a1.stop()
a2.stop()
base.battles.append(TimObjects.Battle([a1, a2]))
def col_army_against_tower(self, entry):
print "TOWER COLLIDE", entry.getIntoNodePath().getParent().getTag("id")
print entry.getIntoNodePath().getParent().getTag(
"player"), "vs", entry.getFromNodePath().getParent().getTag(
"player")
if entry.getIntoNodePath().getParent().getTag(
"player") != entry.getFromNodePath().getParent().getTag(
"player"):
tower = entry.getIntoNodePath()
tower_id = int(tower.getParent().getTag("id"))
invader = int(entry.getFromNodePath().getParent().getTag("player"))
if base.client == False and base.towers[tower_id].capture_check():
base.towers[tower_id].change_owner(invader)
if base.single_player == False:
base.net_manager.server_messager("tower_capture",
[tower_id, invader])
def col_in_object(self, entry):
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(0.5, 0.5, 0.5, 0.1)
#self.global_text.setText(np_into.getName())
if np_into.getTag("type") == "battle":
print "You're in a battle"
#print "in"
def col_out_object(self, entry):
np_into = entry.getIntoNodePath()
#print "out"
try:
np_into.getParent().setColor(1, 1, 1, 1)
except:
print "ERROR CLEARING COLOUR"
#self.global_text.setText("")
self.pickable = None
self.selected_type = "none"
def col_against_object(self, entry):
if entry.getIntoNodePath().getParent() != self.pickable:
np_from = entry.getFromNodePath()
np_into = entry.getIntoNodePath()
self.selected_type = np_into.getTag("type")
self.pickable = np_into.getParent()
def mouse_click(self, status):
print "click"
in_statbar = base.vis_manager.statbar.mouse_in_bar()
if self.pickable and in_statbar == False:
if status == "down":
if self.selected_type == "army":
if base.armies[int(self.pickable.getTag(
"id"))].state == "normal" or base.armies[int(
self.pickable.getTag("id"))].state == "new":
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
self.pickable.setScale(0.95 * 10)
self.selected = int(self.pickable.getTag("id"))
self.selected_node = self.pickable
self.selecteds.append(base.armies[self.selected])
base.armies[self.selected].select()
print "You clicked on Army" + str(self.selected)
base.vis_manager.statbar.show_army(self.selected)
elif self.selected_type == "tower":
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
self.selected = int(self.pickable.getTag("id"))
self.selected_node = self.pickable
self.selecteds.append(base.towers[self.selected])
base.towers[self.selected].select()
print "You clicked on a tower"
base.vis_manager.statbar.show_tower(self.selected)
elif self.selected_type == "battle":
self.selected = int(self.pickable.getTag("id"))
self.selected_node = self.pickable
print "You clicked on a battle"
base.vis_manager.statbar.show_battle(self.selected)
if status == "up":
if self.selected_type == "army":
self.pickable.setScale(1.0 * 10)
elif status == "up" and self.multi_select == True:
self.multi_select = False
self.select_all_in_box()
elif in_statbar == True:
print "in box"
elif self.pickable == None:
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
self.selected = -1
self.selected_node = None
base.vis_manager.statbar.reset_statbar()
def select_all_in_box(self):
for obj in self.selecteds:
obj.deselect()
print obj.my_id, "deselected"
self.selecteds = []
print "select units in box"
for a in base.armies:
if a.node_col.getTag("type") == "army" and (
a.state == "normal"
or a.state == "new") and a.player == base.player:
x = a.get_x()
y = a.get_y()
if self.box_x < self.model.getX(
) and self.box_y > self.model.getY():
if x < self.model.getX(
) and x > self.box_x and y > self.model.getY(
) and y < self.box_y:
self.selecteds.append(a)
a.select()
elif self.box_x < self.model.getX(
) and self.box_y < self.model.getY():
if x < self.model.getX(
) and x > self.box_x and y < self.model.getY(
) and y > self.box_y:
self.selecteds.append(a)
a.select()
elif self.box_x > self.model.getX(
) and self.box_y < self.model.getY():
if x > self.model.getX(
) and x < self.box_x and y < self.model.getY(
) and y > self.box_y:
self.selecteds.append(a)
a.select()
elif self.box_x > self.model.getX(
) and self.box_y > self.model.getY():
if x > self.model.getX(
) and x < self.box_x and y > self.model.getY(
) and y < self.box_y:
self.selecteds.append(a)
a.select()
def task_select_check(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
#if self.multi_select == True:
self.box_x, self.box_y = self.model.getX(), self.model.getY()
taskMgr.add(self.draw_multiselect_box, "multibox")
return task.done
return task.cont
def draw_multiselect_box(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.multi_select = True
self.select_box.remove()
ls = LineSegs()
ls.move_to(self.box_x, self.box_y, 1)
ls.draw_to(self.model.getX(), self.box_y, 1)
ls.draw_to(self.model.getX(), self.model.getY(), 1)
ls.draw_to(self.box_x, self.model.getY(), 1)
ls.draw_to(self.box_x, self.box_y, 1)
node = ls.create()
#text = TextNode('text')
#text.setText(str(self.box_x)+","+str(self.box_y)+"\n"+str(self.model.getX())+","+str(self.model.getY()))
#textnp = NodePath(text)
#textnp.setPos(self.box_x,self.box_y,1)
#textnp.setHpr(0,-90,0)
#textnp.setScale(20.0)
self.select_box = NodePath(node)
#textnp.reparentTo(self.select_box)
self.select_box.reparentTo(render)
return task.cont
else:
self.select_box.hide()
taskMgr.add(self.task_select_check, "updatePicker")
return task.done
def mouse_order(self):
print "mouse_order"
# if self.selected != -1 and base.armies[self.selected].state == "normal":
# print "orders sent"
for a in self.selecteds:
if a.node_col.getTag("type") == "army":
if len(self.selecteds) > 1:
randomness = (len(self.selecteds) - 1) * 10
a.set_target(
True,
self.pos3d.getX() + random.randint(0, randomness) -
randomness / 2,
self.pos3d.getY() + random.randint(0, randomness) -
randomness / 2)
else:
a.set_target(True, self.pos3d.getX(), self.pos3d.getY())
def get_mouse_plane_pos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(
self.pos3d, render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
#print "Mouse ray intersects ground plane at ", self.pos3d
self.model.setPos(render, self.pos3d)
return task.again
def ray_update(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
class DistributedGolfSpot(DistributedObject.DistributedObject, FSM.FSM):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGolfSpot')
positions = ((-45, 100, GolfGlobals.GOLF_BALL_RADIUS),
(-15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(15, 100, GolfGlobals.GOLF_BALL_RADIUS),
(45, 100, GolfGlobals.GOLF_BALL_RADIUS))
toonGolfOffsetPos = Point3(-2, 0, -GolfGlobals.GOLF_BALL_RADIUS)
toonGolfOffsetHpr = Point3(-90, 0, 0)
rotateSpeed = 20
golfPowerSpeed = base.config.GetDouble('golf-power-speed', 3)
golfPowerExponent = base.config.GetDouble('golf-power-exponent', 0.75)
def __init__(self, cr):
DistributedObject.DistributedObject.__init__(self, cr)
FSM.FSM.__init__(self, 'DistributedGolfSpot')
self.boss = None
self.index = None
self.avId = 0
self.toon = None
self.golfSpotSmoother = SmoothMover()
self.golfSpotSmoother.setSmoothMode(SmoothMover.SMOn)
self.smoothStarted = 0
self.__broadcastPeriod = 0.2
if self.index > len(self.positions):
self.notify.error('Invalid index %d' % index)
self.fadeTrack = None
self.setupPowerBar()
self.aimStart = None
self.golfSpotAdviceLabel = None
self.changeSeq = 0
self.lastChangeSeq = 0
self.controlKeyAllowed = False
self.flyBallTracks = {}
self.splatTracks = {}
self.__flyBallBubble = None
self.flyBallHandler = None
self.__flyBallSequenceNum = 0
self.swingInterval = None
self.lastHitSequenceNum = -1
self.goingToReward = False
self.gotHitByBoss = False
self.releaseTrack = None
self.grabTrack = None
self.restoreScaleTrack = None
return
def setBossCogId(self, bossCogId):
self.bossCogId = bossCogId
self.boss = base.cr.doId2do[bossCogId]
self.boss.setGolfSpot(self, self.index)
def setIndex(self, index):
self.index = index
def disable(self):
DistributedObject.DistributedObject.disable(self)
self.ignoreAll()
def delete(self):
DistributedObject.DistributedObject.delete(self)
self.ignoreAll()
self.boss = None
return
def announceGenerate(self):
DistributedObject.DistributedObject.announceGenerate(self)
self.triggerName = self.uniqueName('trigger')
self.triggerEvent = 'enter%s' % self.triggerName
self.smoothName = self.uniqueName('golfSpotSmooth')
self.golfSpotAdviceName = self.uniqueName('golfSpotAdvice')
self.posHprBroadcastName = self.uniqueName('golfSpotBroadcast')
self.ballPowerTaskName = self.uniqueName('updateGolfPower')
self.adjustClubTaskName = self.uniqueName('adjustClub')
self.loadAssets()
self.accept('flyBallHit-%d' % self.index, self.__flyBallHit)
def loadAssets(self):
self.root = render.attachNewNode('golfSpot-%d' % self.index)
self.root.setPos(*self.positions[self.index])
self.ballModel = loader.loadModel('phase_6/models/golf/golf_ball')
self.ballColor = VBase4(1, 1, 1, 1)
if self.index < len(GolfGlobals.PlayerColors):
self.ballColor = VBase4(*GolfGlobals.PlayerColors[self.index])
self.ballModel.setColorScale(self.ballColor)
self.ballModel.reparentTo(self.root)
self.club = loader.loadModel('phase_6/models/golf/putter')
self.clubLookatSpot = self.root.attachNewNode('clubLookat')
self.clubLookatSpot.setY(-(GolfGlobals.GOLF_BALL_RADIUS + 0.1))
cs = CollisionSphere(0, 0, 0, 1)
cs.setTangible(0)
cn = CollisionNode(self.triggerName)
cn.addSolid(cs)
cn.setIntoCollideMask(ToontownGlobals.WallBitmask)
self.trigger = self.root.attachNewNode(cn)
self.trigger.stash()
self.hitBallSfx = loader.loadSfx('phase_6/audio/sfx/Golf_Hit_Ball.ogg')
def cleanup(self):
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if self.releaseTrack:
self.releaseTrack.finish()
self.releaseTrack = None
flyTracks = self.flyBallTracks.values()
for track in flyTracks:
track.finish()
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
if self.restoreScaleTrack:
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
self.root.removeNode()
self.ballModel.removeNode()
self.club.removeNode()
if self.powerBar:
self.powerBar.destroy()
self.powerBar = None
taskMgr.remove(self.triggerName)
self.boss = None
return
def setState(self, state, avId, extraInfo):
if not self.isDisabled():
self.gotHitByBoss = extraInfo
if state == 'C':
self.demand('Controlled', avId)
elif state == 'F':
self.demand('Free')
elif state == 'O':
self.demand('Off')
else:
self.notify.error('Invalid state from AI: %s' % state)
def enterOff(self):
pass
def exitOff(self):
pass
def enterFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack = Sequence(Wait(6), self.getRestoreScaleInterval(), name='restoreScaleTrack')
self.restoreScaleTrack.start()
if self.avId == localAvatar.doId:
if not self.isDisabled():
self.ballModel.setAlphaScale(0.3)
self.ballModel.setTransparency(1)
taskMgr.doMethodLater(5, self.__allowDetect, self.triggerName)
self.fadeTrack = Sequence(Func(self.ballModel.setTransparency, 1), self.ballModel.colorScaleInterval(0.2, VBase4(1, 1, 1, 0.3)), name='fadeTrack-enterFree')
self.fadeTrack.start()
else:
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
self.avId = 0
return
def exitFree(self):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = None
self.restoreScaleTrack.finish()
self.restoreScaleTrack = None
taskMgr.remove(self.triggerName)
self.ballModel.clearTransparency()
self.trigger.stash()
self.ignore(self.triggerEvent)
return
def enterControlled(self, avId):
self.avId = avId
toon = base.cr.doId2do.get(avId)
if not toon:
return
self.enableControlKey()
self.toon = toon
self.grabTrack = self.makeToonGrabInterval(toon)
if avId == localAvatar.doId:
self.boss.toCraneMode()
camera.reparentTo(self.root)
camera.setPosHpr(0, -10, 3, 0, 0, 0)
localAvatar.setPos(self.root, self.toonGolfOffsetPos)
localAvatar.setHpr(self.root, self.toonGolfOffsetHpr)
localAvatar.sendCurrentPosition()
self.__enableControlInterface()
self.startPosHprBroadcast()
self.accept('exitCrane', self.gotBossZapped)
self.grabTrack.start()
def exitControlled(self):
self.grabTrack.finish()
del self.grabTrack
if self.swingInterval:
self.swingInterval.finish()
self.swingInterval = None
if not self.ballModel.isEmpty():
if self.ballModel.isHidden():
self.notify.debug('ball is hidden scale =%s' % self.ballModel.getScale())
else:
self.notify.debug('ball is showing scale=%s' % self.ballModel.getScale())
if self.toon and not self.toon.isDisabled():
self.toon.startSmooth()
self.releaseTrack = self.makeToonReleaseInterval(self.toon)
self.stopPosHprBroadcast()
self.stopSmooth()
if self.avId == localAvatar.doId:
self.__disableControlInterface()
if not self.goingToReward:
camera.reparentTo(base.localAvatar)
camera.setPos(base.localAvatar.cameraPositions[0][0])
camera.setHpr(0, 0, 0)
self.stopAdjustClubTask()
self.releaseTrack.start()
self.enableControlKey()
return
def __allowDetect(self, task):
if self.fadeTrack:
self.fadeTrack.finish()
self.fadeTrack = Sequence(self.ballModel.colorScaleInterval(0.2, self.ballColor), Func(self.ballModel.clearTransparency), name='fadeTrack-allowDetect')
self.fadeTrack.start()
self.trigger.unstash()
self.accept(self.triggerEvent, self.__hitTrigger)
def __hitTrigger(self, event):
self.d_requestControl()
def getRestoreScaleInterval(self):
return Sequence()
def d_requestControl(self):
self.sendUpdate('requestControl')
def d_requestFree(self, gotHitByBoss):
self.sendUpdate('requestFree', [gotHitByBoss])
def makeToonGrabInterval(self, toon):
origPos = toon.getPos(self.root)
origHpr = toon.getHpr(self.root)
a = self.accomodateToon(toon)
newPos = toon.getPos()
newHpr = toon.getHpr()
origHpr.setX(PythonUtil.fitSrcAngle2Dest(origHpr[0], newHpr[0]))
self.notify.debug('toon.setPosHpr %s %s' % (origPos, origHpr))
toon.setPosHpr(origPos, origHpr)
walkTime = 0.2
reach = Sequence()
if reach.getDuration() < walkTime:
reach = Sequence(ActorInterval(toon, 'walk', loop=1, duration=walkTime - reach.getDuration()), reach)
i = Sequence(Parallel(toon.posInterval(walkTime, newPos, origPos), toon.hprInterval(walkTime, newHpr, origHpr), reach), Func(toon.stopLookAround))
if toon == base.localAvatar:
i.append(Func(self.switchToAnimState, 'GolfPuttLoop'))
i.append(Func(self.startAdjustClubTask))
i = Parallel(i, a)
return i
def accomodateToon(self, toon):
toon.wrtReparentTo(self.root)
toon.setPos(self.toonGolfOffsetPos)
toon.setHpr(self.toonGolfOffsetHpr)
return Sequence()
def switchToAnimState(self, animStateName, forced = False):
curAnimState = base.localAvatar.animFSM.getCurrentState()
curAnimStateName = ''
if curAnimState:
curAnimStateName = curAnimState.getName()
if curAnimStateName != animStateName or forced:
base.localAvatar.b_setAnimState(animStateName)
def __enableControlInterface(self):
gui = loader.loadModel('phase_3.5/models/gui/avatar_panel_gui')
self.closeButton = DirectButton(image=(gui.find('**/CloseBtn_UP'),
gui.find('**/CloseBtn_DN'),
gui.find('**/CloseBtn_Rllvr'),
gui.find('**/CloseBtn_UP')), relief=None, scale=2, text=TTLocalizer.BossbotGolfSpotLeave, text_scale=0.04, text_pos=(0, -0.07), text_fg=VBase4(1, 1, 1, 1), pos=(1.05, 0, -0.82), command=self.__exitGolfSpot)
self.accept('escape', self.__exitGolfSpot)
self.accept('control', self.__controlPressed)
self.accept('control-up', self.__controlReleased)
self.accept('InputState-forward', self.__upArrow)
self.accept('InputState-reverse', self.__downArrow)
self.accept('InputState-turnLeft', self.__leftArrow)
self.accept('InputState-turnRight', self.__rightArrow)
taskMgr.add(self.__watchControls, 'watchGolfSpotControls')
taskMgr.doMethodLater(5, self.__displayGolfSpotAdvice, self.golfSpotAdviceName)
self.arrowVert = 0
self.arrowHorz = 0
if self.powerBar:
self.powerBar.show()
return
def __disableControlInterface(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = None
self.__cleanupGolfSpotAdvice()
self.ignore('escape')
self.ignore('control')
self.ignore('control-up')
self.ignore('InputState-forward')
self.ignore('InputState-reverse')
self.ignore('InputState-turnLeft')
self.ignore('InputState-turnRight')
self.arrowVert = 0
self.arrowHorz = 0
taskMgr.remove('watchGolfSpotControls')
if self.powerBar:
self.powerBar.hide()
else:
self.notify.debug('self.powerBar is none')
return
def setupPowerBar(self):
self.powerBar = DirectWaitBar(pos=(0.0, 0, -0.94), relief=DGG.SUNKEN, frameSize=(-2.0,
2.0,
-0.2,
0.2), borderWidth=(0.02, 0.02), scale=0.25, range=100, sortOrder=50, frameColor=(0.5, 0.5, 0.5, 0.5), barColor=(1.0, 0.0, 0.0, 1.0), text='', text_scale=0.26, text_fg=(1, 1, 1, 1), text_align=TextNode.ACenter, text_pos=(0, -0.05))
self.power = 0
self.powerBar['value'] = self.power
self.powerBar.hide()
def resetPowerBar(self):
self.power = 0
self.powerBar['value'] = self.power
self.powerBar['text'] = ''
def __displayGolfSpotAdvice(self, task):
if self.golfSpotAdviceLabel == None:
self.golfSpotAdviceLabel = DirectLabel(text=TTLocalizer.BossbotGolfSpotAdvice, text_fg=VBase4(1, 1, 1, 1), text_align=TextNode.ACenter, relief=None, pos=(0, 0, 0.69), scale=0.1)
return
def __cleanupGolfSpotAdvice(self):
if self.golfSpotAdviceLabel:
self.golfSpotAdviceLabel.destroy()
self.golfSpotAdviceLabel = None
taskMgr.remove(self.golfSpotAdviceName)
return
def showExiting(self):
if self.closeButton:
self.closeButton.destroy()
self.closeButton = DirectLabel(relief=None, text=TTLocalizer.BossbotGolfSpotLeaving, pos=(1.05, 0, -0.88), text_pos=(0, 0), text_scale=0.06, text_fg=VBase4(1, 1, 1, 1))
self.__cleanupGolfSpotAdvice()
return
def __exitGolfSpot(self):
self.d_requestFree(False)
def __controlPressed(self):
if self.controlKeyAllowed:
self.__beginFireBall()
def __controlReleased(self):
if self.controlKeyAllowed:
self.__endFireBall()
def __upArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = 1
elif self.arrowVert > 0:
self.arrowVert = 0
def __downArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowVert = -1
elif self.arrowVert < 0:
self.arrowVert = 0
def __rightArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = 1
self.switchToAnimState('GolfRotateLeft')
elif self.arrowHorz > 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __leftArrow(self, pressed):
self.__incrementChangeSeq()
self.__cleanupGolfSpotAdvice()
if pressed:
self.arrowHorz = -1
self.switchToAnimState('GolfRotateRight')
elif self.arrowHorz < 0:
self.arrowHorz = 0
self.switchToAnimState('GolfPuttLoop')
def __watchControls(self, task):
if self.arrowHorz:
self.__moveGolfSpot(self.arrowHorz)
return Task.cont
def __moveGolfSpot(self, xd):
dt = globalClock.getDt()
h = self.root.getH() - xd * self.rotateSpeed * dt
h %= 360
limitH = h
self.root.setH(limitH)
def __incrementChangeSeq(self):
self.changeSeq = self.changeSeq + 1 & 255
def __beginFireBall(self):
if self.aimStart != None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
time = globalClock.getFrameTime()
self.aimStart = time
messenger.send('wakeup')
taskMgr.add(self.__updateBallPower, self.ballPowerTaskName)
return
def __endFireBall(self):
if self.aimStart == None:
return
if not self.state == 'Controlled':
return
if not self.avId == localAvatar.doId:
return
taskMgr.remove(self.ballPowerTaskName)
self.disableControlKey()
messenger.send('wakeup')
self.aimStart = None
power = self.power
angle = self.root.getH()
self.notify.debug('incrementing self.__flyBallSequenceNum')
self.__flyBallSequenceNum = (self.__flyBallSequenceNum + 1) % 255
self.sendSwingInfo(power, angle, self.__flyBallSequenceNum)
self.setSwingInfo(power, angle, self.__flyBallSequenceNum)
self.resetPowerBar()
return
def __updateBallPower(self, task):
if not self.powerBar:
print '### no power bar!!!'
return task.done
newPower = self.__getBallPower(globalClock.getFrameTime())
self.power = newPower
self.powerBar['value'] = newPower
return task.cont
def __getBallPower(self, time):
elapsed = max(time - self.aimStart, 0.0)
t = elapsed / self.golfPowerSpeed
t = math.pow(t, self.golfPowerExponent)
power = int(t * 100) % 200
if power > 100:
power = 200 - power
return power
def stopPosHprBroadcast(self):
taskName = self.posHprBroadcastName
taskMgr.remove(taskName)
def startPosHprBroadcast(self):
taskName = self.posHprBroadcastName
self.b_clearSmoothing()
self.d_sendGolfSpotPos()
taskMgr.remove(taskName)
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName)
def __posHprBroadcast(self, task):
self.d_sendGolfSpotPos()
taskName = self.posHprBroadcastName
taskMgr.doMethodLater(self.__broadcastPeriod, self.__posHprBroadcast, taskName)
return Task.done
def d_sendGolfSpotPos(self):
timestamp = globalClockDelta.getFrameNetworkTime()
self.sendUpdate('setGolfSpotPos', [self.changeSeq, self.root.getH(), timestamp])
def setGolfSpotPos(self, changeSeq, h, timestamp):
self.changeSeq = changeSeq
if self.smoothStarted:
now = globalClock.getFrameTime()
local = globalClockDelta.networkToLocalTime(timestamp, now)
self.golfSpotSmoother.setH(h)
self.golfSpotSmoother.setTimestamp(local)
self.golfSpotSmoother.markPosition()
else:
self.root.setH(h)
def b_clearSmoothing(self):
self.d_clearSmoothing()
self.clearSmoothing()
def d_clearSmoothing(self):
self.sendUpdate('clearSmoothing', [0])
def clearSmoothing(self, bogus = None):
self.golfSpotSmoother.clearPositions(1)
def doSmoothTask(self, task):
self.golfSpotSmoother.computeAndApplySmoothHpr(self.root)
return Task.cont
def startSmooth(self):
if not self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.reloadPosition()
taskMgr.add(self.doSmoothTask, taskName)
self.smoothStarted = 1
def stopSmooth(self):
if self.smoothStarted:
taskName = self.smoothName
taskMgr.remove(taskName)
self.forceToTruePosition()
self.smoothStarted = 0
def makeToonReleaseInterval(self, toon):
def getSlideToPos(toon = toon):
return render.getRelativePoint(toon, Point3(0, -5, 0))
if self.gotHitByBoss:
grabIval = Sequence(Func(self.detachClub), name='makeToonReleaseInterval-gotHitByBoss')
if not toon.isEmpty():
toonIval = Sequence(Func(toon.wrtReparentTo, render), Parallel(ActorInterval(toon, 'slip-backward'), toon.posInterval(0.5, getSlideToPos, fluid=1)), name='makeToonReleaseInterval-toonIval')
grabIval.append(toonIval)
else:
grabIval = Sequence(Func(self.detachClub))
if not toon.isEmpty():
toonIval = Sequence(Parallel(ActorInterval(toon, 'walk', duration=1.0, playRate=-1.0), LerpPosInterval(toon, duration=1.0, pos=Point3(-10, 0, 0))), Func(toon.wrtReparentTo, render))
grabIval.append(toonIval)
if localAvatar.doId == toon.doId:
if not self.goingToReward and toon.hp > 0:
grabIval.append(Func(self.goToFinalBattle))
grabIval.append(Func(self.notify.debug, 'goingToFinalBattlemode'))
grabIval.append(Func(self.safeBossToFinalBattleMode))
return grabIval
def safeBossToFinalBattleMode(self):
if self.boss:
self.boss.toFinalBattleMode()
def goToFinalBattle(self):
if self.cr:
place = self.cr.playGame.getPlace()
if place and hasattr(place, 'fsm'):
curState = place.fsm.getCurrentState().getName()
if place.fsm.getCurrentState().getName() == 'crane':
place.setState('finalBattle')
else:
self.notify.debug('NOT going to final battle, state=%s' % curState)
def attachClub(self, avId, pointToBall = False):
club = self.club
if club:
av = base.cr.doId2do.get(avId)
if av:
av.useLOD(1000)
lHand = av.getLeftHands()[0]
club.setPos(0, 0, 0)
club.reparentTo(lHand)
netScale = club.getNetTransform().getScale()[1]
counterActToonScale = lHand.find('**/counteractToonScale')
if counterActToonScale.isEmpty():
counterActToonScale = lHand.attachNewNode('counteractToonScale')
counterActToonScale.setScale(1 / netScale)
self.notify.debug('creating counterActToonScale for %s' % av.getName())
club.reparentTo(counterActToonScale)
club.setX(-0.25 * netScale)
if pointToBall:
club.lookAt(self.clubLookatSpot)
def detachClub(self):
if not self.club.isEmpty():
self.club.reparentTo(self.root)
self.club.setZ(-20)
self.club.setScale(1)
def adjustClub(self):
club = self.club
if club:
distance = club.getDistance(self.clubLookatSpot)
scaleFactor = distance / 2.058
club.setScale(1, scaleFactor, 1)
def startAdjustClubTask(self):
taskMgr.add(self.adjustClubTask, self.adjustClubTaskName)
def stopAdjustClubTask(self):
taskMgr.remove(self.adjustClubTaskName)
def adjustClubTask(self, task):
self.attachClub(self.avId, True)
self.adjustClub()
return task.cont
def enableControlKey(self):
self.controlKeyAllowed = True
def disableControlKey(self):
self.controlKeyAllowed = False
def sendSwingInfo(self, power, angle, sequenceNum):
self.sendUpdate('setSwingInfo', [power, angle, sequenceNum])
def startBallPlayback(self, power, angle, sequenceNum):
flyBall = self.ballModel.copyTo(NodePath())
flyBall.setScale(1.0)
flyBallBubble = self.getFlyBallBubble().instanceTo(NodePath())
flyBallBubble.reparentTo(flyBall)
flyBall.setTag('pieSequence', str(sequenceNum))
flyBall.setTag('throwerId', str(self.avId))
t = power / 100.0
t = 1.0 - t
dist = 300 - 200 * t
time = 1.5 + 0.5 * t
proj = ProjectileInterval(None, startPos=Point3(0, 0, 0), endPos=Point3(0, dist, 0), duration=time)
relVel = proj.startVel
def getVelocity(root = self.root, relVel = relVel):
return render.getRelativeVector(root, relVel)
fly = Sequence(Func(flyBall.reparentTo, render), Func(flyBall.setPosHpr, self.root, 0, 0, 0, 0, 0, 0), Func(base.cTrav.addCollider, flyBallBubble, self.flyBallHandler), ProjectileInterval(flyBall, startVel=getVelocity, duration=3), Func(flyBall.detachNode), Func(base.cTrav.removeCollider, flyBallBubble), Func(self.notify.debug, 'removed collider'), Func(self.flyBallFinishedFlying, sequenceNum))
flyWithSound = Parallel(fly, SoundInterval(self.hitBallSfx, node=self.root), name='flyWithSound')
self.notify.debug('starting flyball track')
flyWithSound.start()
self.flyBallTracks[sequenceNum] = flyWithSound
return
def setSwingInfo(self, power, angle, sequenceNum):
av = base.cr.doId2do.get(self.avId)
self.swingInterval = Sequence()
if av:
self.stopAdjustClubTask()
self.swingInterval = Sequence(ActorInterval(av, 'swing-putt', startFrame=0, endFrame=GolfGlobals.BALL_CONTACT_FRAME), Func(self.startBallPlayback, power, angle, sequenceNum), Func(self.ballModel.hide), ActorInterval(av, 'swing-putt', startFrame=GolfGlobals.BALL_CONTACT_FRAME, endFrame=24), Func(self.ballModel.setScale, 0.1), Func(self.ballModel.show), LerpScaleInterval(self.ballModel, 1.0, Point3(1, 1, 1)), Func(self.enableControlKey))
if av == localAvatar:
self.swingInterval.append(Func(self.switchToAnimState, 'GolfPuttLoop', True))
self.swingInterval.start()
def getFlyBallBubble(self):
if self.__flyBallBubble == None:
bubble = CollisionSphere(0, 0, 0, GolfGlobals.GOLF_BALL_RADIUS)
node = CollisionNode('flyBallBubble')
node.addSolid(bubble)
node.setFromCollideMask(ToontownGlobals.PieBitmask | ToontownGlobals.CameraBitmask | ToontownGlobals.FloorBitmask)
node.setIntoCollideMask(BitMask32.allOff())
self.__flyBallBubble = NodePath(node)
self.flyBallHandler = CollisionHandlerEvent()
self.flyBallHandler.addInPattern('flyBallHit-%d' % self.index)
return self.__flyBallBubble
def __flyBallHit(self, entry):
print entry
def flyBallFinishedFlying(self, sequence):
if self.flyBallTracks.has_key(sequence):
del self.flyBallTracks[sequence]
def __finishFlyBallTrack(self, sequence):
if self.flyBallTracks.has_key(sequence):
flyBallTrack = self.flyBallTracks[sequence]
del self.flyBallTracks[sequence]
flyBallTrack.finish()
def flyBallFinishedSplatting(self, sequence):
if self.splatTracks.has_key(sequence):
del self.splatTracks[sequence]
def __flyBallHit(self, entry):
if not entry.hasSurfacePoint() or not entry.hasInto():
return
if not entry.getInto().isTangible():
return
sequence = int(entry.getFromNodePath().getNetTag('pieSequence'))
self.__finishFlyBallTrack(sequence)
if self.splatTracks.has_key(sequence):
splatTrack = self.splatTracks[sequence]
del self.splatTracks[sequence]
splatTrack.finish()
flyBallCode = 0
flyBallCodeStr = entry.getIntoNodePath().getNetTag('pieCode')
if flyBallCodeStr:
flyBallCode = int(flyBallCodeStr)
pos = entry.getSurfacePoint(render)
timestamp32 = globalClockDelta.getFrameNetworkTime(bits=32)
throwerId = int(entry.getFromNodePath().getNetTag('throwerId'))
splat = self.getFlyBallSplatInterval(pos[0], pos[1], pos[2], flyBallCode, throwerId)
splat = Sequence(splat, Func(self.flyBallFinishedSplatting, sequence))
self.splatTracks[sequence] = splat
splat.start()
self.notify.debug('doId=%d into=%s flyBallCode=%d, throwerId=%d' % (self.doId,
entry.getIntoNodePath(),
flyBallCode,
throwerId))
if flyBallCode == ToontownGlobals.PieCodeBossCog and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
self.boss.d_ballHitBoss(1)
elif flyBallCode == ToontownGlobals.PieCodeToon and self.avId == localAvatar.doId and self.lastHitSequenceNum != self.__flyBallSequenceNum:
self.lastHitSequenceNum = self.__flyBallSequenceNum
avatarDoId = entry.getIntoNodePath().getNetTag('avatarDoId')
if avatarDoId == '':
self.notify.warning('Toon %s has no avatarDoId tag.' % repr(entry.getIntoNodePath()))
return
doId = int(avatarDoId)
if doId != localAvatar.doId:
pass
def getFlyBallSplatInterval(self, x, y, z, flyBallCode, throwerId):
from toontown.toonbase import ToontownBattleGlobals
from toontown.battle import BattleProps
splatName = 'dust'
splat = BattleProps.globalPropPool.getProp(splatName)
splat.setBillboardPointWorld(2)
color = ToontownGlobals.PieCodeColors.get(flyBallCode)
if color:
splat.setColor(*color)
if flyBallCode == ToontownGlobals.PieCodeBossCog:
self.notify.debug('changing color to %s' % self.ballColor)
splat.setColor(self.ballColor)
sound = loader.loadSfx('phase_11/audio/sfx/LB_evidence_miss.ogg')
vol = 1.0
if flyBallCode == ToontownGlobals.PieCodeBossCog:
sound = loader.loadSfx('phase_4/audio/sfx/Golf_Hit_Barrier_1.ogg')
soundIval = SoundInterval(sound, node=splat, volume=vol)
if flyBallCode == ToontownGlobals.PieCodeBossCog and localAvatar.doId == throwerId:
vol = 1.0
soundIval = SoundInterval(sound, node=localAvatar, volume=vol)
ival = Parallel(Func(splat.reparentTo, render), Func(splat.setPos, x, y, z), soundIval, Sequence(ActorInterval(splat, splatName), Func(splat.detachNode)))
return ival
def setGoingToReward(self):
self.goingToReward = True
def gotBossZapped(self):
self.showExiting()
self.d_requestFree(True)
class Level:
''' Combines level geometry, behaviour and model '''
POS_DEFAULT = (0, 0, 0)
SCALE_DEFAULT = (1, 1, 1)
def __init__(
self,
model,
mapNo,
pos=POS_DEFAULT,
scale=SCALE_DEFAULT,
):
self.model = model
self.space = model.space
self.world = model.world
self.pos = pos
self.scale = scale
self._planes = []
self._coins = []
self._triggers = []
self.levelNode = None
self.exit = MovingPlane(self.space, (0.0, 5.0, 1.0), (1.0, 1.0, 1.0))
self.ball = model.getBall()
self.goal = 0 # kerattavat kolikot
print 'Loading level ', mapNo, '...'
self.initCollisionTest()
factory = LevelFactory()
factory.load(self, mapNo)
def initCollisionTest(self):
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
base.cTrav = CollisionTraverser('test name')
if False:
base.cTrav.showCollisions(render)
cName = 'BallCollNode'
cSphere = CollisionSphere(0, 0, 0, 1.0)
cNode = CollisionNode(cName)
cNode.addSolid(cSphere)
cNodePath = self.ball.modelNode.attachNewNode(cNode)
base.cTrav.addCollider(cNodePath, self.collHandEvent)
def onTrigger(self, entry):
print 'trigger on'
def loadLevelEntity(self, mEgg, cEgg):
self.levelNode = self._createModelNode(self.pos, self.scale, mEgg)
self.collNode = loader.loadModel(cEgg)
self.trimesh = OdeTriMeshData(self.collNode, True)
self.collGeom = OdeTriMeshGeom(self.space, self.trimesh)
self.space.setSurfaceType(self.collGeom, SurfaceType.FLOOR)
self.levelNode.flattenStrong()
self.levelNode.reparentTo(render)
def _createModelNode(self, pos, scale, modelEgg):
modelNode = loader.loadModel(modelEgg)
modelNode.setPos(pos)
modelNode.setScale(scale)
return modelNode
def updateModelNode(self):
map(Coin.updateModelNode, self._coins)
map(MovingPlane.updateModelNode, self._planes)
self.exit.updateModelNode()
def removeLevel(self):
self.collGeom = None
if (self.levelNode != None):
self.levelNode.removeNode()
map(MovingPlane.removeNode, self._planes)
map(Coin.removeNode, self._coins)
if (self.exit != None):
self.exit.removeNode()
def getExit(self):
''' Return the geometry of an exit'''
return self.exit.getGeom()
def getGoal(self):
return self.goal
def addCoin(self, pos):
self._coins.append(Coin(self.model, self.world, self.space, pos))
def getCoins(self):
return self._coins
def addTrigger(self, name, pos, radius):
'''
http://www.panda3d.org/apiref.php?page=DirectObject
http://www.panda3d.org/wiki/index.php/Collision_Solids
http://www.panda3d.org/apiref.php?page=CollisionTraverser
http://www.panda3d.org/apiref.php?page=CollisionHandlerEvent
http://www.panda3d.org/apiref.php?page=NodePath#find
'''
cSphere = CollisionSphere(pos[0], pos[1], pos[2], radius)
cNode = CollisionNode(name)
cNode.addSolid(cSphere)
model = render.find(name)
if not model.isEmpty():
model.removeNode()
cnodePath = render.attachNewNode(cNode)
cnodePath.show()
base.cTrav.addCollider(cnodePath, self.collHandEvent)
base.accept('into-' + name, self.onTrigger)
def addPlane(self, pos, dim, type):
self._planes.append(MovingPlane(self.space, pos, dim, type))
def addExit(self, pos):
self.exit.setPosition(pos)
self.addTrigger('ExitTriggerNode', pos, 2.0)
class CogdoFlyingCollisions(GravityWalker):
wantFloorSphere = 0
def __init__(self):
GravityWalker.__init__(self, gravity=0.0)
def initializeCollisions(self,
collisionTraverser,
avatarNodePath,
avatarRadius=1.4,
floorOffset=1.0,
reach=1.0):
self.cHeadSphereNodePath = None
self.cFloorEventSphereNodePath = None
self.setupHeadSphere(avatarNodePath)
self.setupFloorEventSphere(avatarNodePath,
ToontownGlobals.FloorEventBitmask,
avatarRadius)
GravityWalker.initializeCollisions(self, collisionTraverser,
avatarNodePath, avatarRadius,
floorOffset, reach)
return
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def setupEventSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius * 1.04)
cSphere.setTangible(0)
cSphereNode = CollisionNode('Flyer.cEventSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.event = CollisionHandlerEvent()
self.event.addInPattern('enter%in')
self.event.addOutPattern('exit%in')
self.cEventSphereNodePath = cSphereNodePath
def setupRay(self, bitmask, floorOffset, reach):
cRay = CollisionRay(0.0, 0.0, 3.0, 0.0, 0.0, -1.0)
cRayNode = CollisionNode('Flyer.cRayNode')
cRayNode.addSolid(cRay)
self.cRayNodePath = self.avatarNodePath.attachNewNode(cRayNode)
cRayNode.setFromCollideMask(bitmask)
cRayNode.setIntoCollideMask(BitMask32.allOff())
self.lifter = CollisionHandlerGravity()
self.lifter.setLegacyMode(self._legacyLifter)
self.lifter.setGravity(self.getGravity(0))
self.lifter.addInPattern('%fn-enter-%in')
self.lifter.addAgainPattern('%fn-again-%in')
self.lifter.addOutPattern('%fn-exit-%in')
self.lifter.setOffset(floorOffset)
self.lifter.setReach(reach)
self.lifter.addCollider(self.cRayNodePath, self.avatarNodePath)
def setupHeadSphere(self, avatarNodePath):
collSphere = CollisionSphere(0, 0, 0, 1)
collSphere.setTangible(1)
collNode = CollisionNode('Flyer.cHeadCollSphere')
collNode.setFromCollideMask(ToontownGlobals.CeilingBitmask)
collNode.setIntoCollideMask(BitMask32.allOff())
collNode.addSolid(collSphere)
self.cHeadSphereNodePath = avatarNodePath.attachNewNode(collNode)
self.cHeadSphereNodePath.setZ(base.localAvatar.getHeight() + 1.0)
self.headCollisionEvent = CollisionHandlerEvent()
self.headCollisionEvent.addInPattern('%fn-enter-%in')
self.headCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
def setupFloorEventSphere(self, avatarNodePath, bitmask, avatarRadius):
cSphere = CollisionSphere(0.0, 0.0, 0.0, 0.75)
cSphereNode = CollisionNode('Flyer.cFloorEventSphere')
cSphereNode.addSolid(cSphere)
cSphereNodePath = avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
self.floorCollisionEvent = CollisionHandlerEvent()
self.floorCollisionEvent.addInPattern('%fn-enter-%in')
self.floorCollisionEvent.addAgainPattern('%fn-again-%in')
self.floorCollisionEvent.addOutPattern('%fn-exit-%in')
base.cTrav.addCollider(cSphereNodePath, self.floorCollisionEvent)
self.cFloorEventSphereNodePath = cSphereNodePath
def deleteCollisions(self):
GravityWalker.deleteCollisions(self)
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
self.cHeadSphereNodePath.detachNode()
self.cHeadSphereNodePath = None
self.headCollisionsEvent = None
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
self.cFloorEventSphereNodePath.detachNode()
self.cFloorEventSphereNodePath = None
self.floorCollisionEvent = None
self.cRayNodePath.detachNode()
del self.cRayNodePath
self.cEventSphereNodePath.detachNode()
del self.cEventSphereNodePath
return
def setCollisionsActive(self, active=1):
if self.collisionsActive != active:
if self.cHeadSphereNodePath != None:
base.cTrav.removeCollider(self.cHeadSphereNodePath)
if active:
base.cTrav.addCollider(self.cHeadSphereNodePath,
self.headCollisionEvent)
if self.cFloorEventSphereNodePath != None:
base.cTrav.removeCollider(self.cFloorEventSphereNodePath)
if active:
base.cTrav.addCollider(self.cFloorEventSphereNodePath,
self.floorCollisionEvent)
GravityWalker.setCollisionsActive(self, active)
return
def enableAvatarControls(self):
pass
def disableAvatarControls(self):
pass
def handleAvatarControls(self, task):
pass
class CollisionManager:
def __init__(self):
self.line_dir = NodePath()
base.cTrav = CollisionTraverser()
self.col_handler = CollisionHandlerEvent()
picker_node = CollisionNode("mouseRayNode")
pickerNPos = base.camera.attachNewNode(picker_node)
self.pickerRay = CollisionRay()
picker_node.addSolid(self.pickerRay)
plane_node = CollisionNode("base_plane")
plane = base.render.attachNewNode(plane_node)
self.plane_col = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
picker_node.addSolid(self.pickerRay)
picker_node.setTag("rays", "mray")
base.cTrav.addCollider(pickerNPos, self.col_handler)
self.col_handler.addInPattern("%(rays)ft-into-%(type)it")
self.col_handler.addOutPattern("%(rays)ft-out-%(type)it")
self.col_handler.addAgainPattern("ray_again_all%("
"rays"
")fh%("
"type"
")ih")
self.model = loader.loadModel("../models/chest.egg")
self.model_node = NodePath("sdfafd")
self.model.reparentTo(self.model_node)
self.model_node.reparentTo(render)
#
# self.text_node = TextNode("battle_text")
# self.text_node.setText("TEXTYTEXTYTEXTTEXT")
# self.text_node_path = render.attachNewNode(self.text_node)
# self.text_node_path.reparentTo(render)
# self.text_node_path.setPos(0,0,4)
# self.text_node_path.setHpr(0,0,0)
# self.text_node_path.setScale(1)
# #self.text_node_path.setTransparency(TransparencyAttrib.MAlpha)
# self.text_node.setTextColor((1,1,1,1))
# self.text_node.setAlign(TextNode.ALeft)
self.placement_ghost = EditorObjects.PlacementGhost(
0, "tower", base.object_scale)
z = 0
self.plane = Plane(Vec3(0, 0, 1), Point3(0, 0, z))
taskMgr.add(self.ray_update, "updatePicker")
taskMgr.add(self.get_mouse_plane_pos, "MousePositionOnPlane")
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
self.input_init()
self.pickable = None
def input_init(self):
self.DO = DirectObject()
self.DO.accept('mouse1', self.mouse_click, ["1-down"])
self.DO.accept('mouse1-up', self.mouse_click, ["1-up"])
self.DO.accept('mouse3', self.mouse_click, ["3-down"])
self.DO.accept('0', self.placement_ghost.change_player, [0])
self.DO.accept('1', self.placement_ghost.change_player, [1])
self.DO.accept('2', self.placement_ghost.change_player, [2])
self.DO.accept('a', self.placement_ghost.change_type, ["army"])
self.DO.accept('t', self.placement_ghost.change_type, ["tower"])
self.DO.accept('control-s', base.xml_manager.save)
self.DO.accept('mray-into-army', self.col_in_object)
self.DO.accept('mray-out-army', self.col_out_object)
self.DO.accept('mray-into-tower', self.col_in_object)
self.DO.accept('mray-out-tower', self.col_out_object)
self.DO.accept('ray_again_all', self.col_against_object)
def col_against_object(self, entry):
if entry.getIntoNodePath().getParent() != self.pickable:
np_from = entry.getFromNodePath()
np_into = entry.getIntoNodePath()
self.selected_type = np_into.getTag("type")
self.pickable = np_into.getParent()
def col_in_object(self, entry):
if base.state == "selecting":
np_into = entry.getIntoNodePath()
np_into.getParent().setColor(0.5, 0.5, 0.5, 1)
def col_out_object(self, entry):
np_into = entry.getIntoNodePath()
try:
np_into.getParent().clearColor()
except:
print "ERROR CLEARING COLOUR"
def get_mouse_plane_pos(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pos3d = Point3()
nearPoint = Point3()
farPoint = Point3()
base.camLens.extrude(mpos, nearPoint, farPoint)
if self.plane.intersectsLine(
self.pos3d, render.getRelativePoint(camera, nearPoint),
render.getRelativePoint(camera, farPoint)):
#print "Mouse ray intersects ground plane at ", self.pos3d
self.model_node.setPos(render, self.pos3d)
self.placement_ghost.set_position(self.pos3d[0], self.pos3d[1])
return task.again
def ray_update(self, task):
if base.mouseWatcherNode.hasMouse():
mpos = base.mouseWatcherNode.getMouse()
self.pickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
return task.cont
def task_mouse_place(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
self.placing_object = True
self.place_pos = (self.anchor_x, self.anchor_y)
self.line_dir.remove()
ls = LineSegs()
ls.move_to(self.anchor_x, self.anchor_y, 1)
ls.draw_to(self.model.getX(), self.model.getY(), 1)
node = ls.create()
angle1 = math.atan2(self.anchor_y - self.anchor_y,
self.anchor_x - self.anchor_x + 50)
angle2 = math.atan2(self.anchor_y - self.model.getY(),
self.anchor_x - self.model.getY())
final_angle = angle1 - angle2
self.model.setHpr(final_angle, 0, 0)
self.line_dir = NodePath(node)
self.line_dir.reparentTo(render)
return task.again
else:
self.line_dir.hide()
taskMgr.add(self.task_mouse_press_check, "checkMousePress")
return task.done
def task_mouse_press_check(self, task):
if base.mouseWatcherNode.isButtonDown(MouseButton.one()):
#if self.multi_select == True:
self.anchor_x, self.anchor_y = self.model.getX(), self.model.getY()
taskMgr.add(self.task_mouse_place, "multibox")
return task.done
return task.again
def mouse_click(self, status):
print base.state
if status == "1-down":
if base.state == "placement":
if self.placement_ghost.get_type() == "tower":
obj = self.placement_ghost.place("tower",
self.model.getX(),
self.model.getY())
elif self.placement_ghost.get_type() == "army":
obj = self.placement_ghost.place("army", self.model.getX(),
self.model.getY())
base.details_box.set_object(obj)
base.change_state("modifying")
elif base.state == "moving":
obj = base.details_box.get_object()
obj.set_position(self.pos3d[0], self.pos3d[1])
base.change_state("modifying")
elif base.state == "selecting" and self.pickable != None:
obj = base.get_obj_from_node(self.pickable)
base.details_box.set_object(obj, "selecting")
base.change_state("modifying")
elif status == "1-up":
print "Mouse", status
elif status == "3-down":
if base.state == "placement":
base.change_state("selecting")
elif base.state == "selecting":
base.change_state("placement")
class CogdoMazeLocalPlayer(CogdoMazePlayer):
notify = directNotify.newCategory('CogdoMazeLocalPlayer')
def __init__(self, id, toon, game, guiMgr):
CogdoMazePlayer.__init__(self, id, toon)
self.disableGagCollision()
self.game = game
self.maze = self.game.maze
self._guiMgr = guiMgr
self.cameraMgr = CogdoMazeCameraManager(self.toon, self.maze, camera,
render)
self._proximityRadius = self.maze.cellWidth * Globals.CameraRemoteToonRadius
orthoDrive = OrthoDrive(
Globals.ToonRunSpeed,
maxFrameMove=self.maze.cellWidth / 2,
customCollisionCallback=self.maze.doOrthoCollisions,
wantSound=True)
self.orthoWalk = OrthoWalk(orthoDrive)
self._audioMgr = base.cogdoGameAudioMgr
self._getMemoSfx = self._audioMgr.createSfx('getMemo',
source=self.toon)
self._waterCoolerFillSfx = self._audioMgr.createSfx('waterCoolerFill',
source=self.toon)
self._hitByDropSfx = self._audioMgr.createSfx('toonHitByDrop',
source=self.toon)
self._winSfx = self._audioMgr.createSfx('win')
self._loseSfx = self._audioMgr.createSfx('lose')
self.enabled = False
self.pickupCount = 0
self.numEntered = 0
self.throwPending = False
self.coolDownAfterHitInterval = Sequence(
Wait(Globals.HitCooldownTime),
Func(self.setInvulnerable, False),
name='coolDownAfterHitInterval-%i' % self.toon.doId)
self.invulnerable = False
self.gagHandler = CollisionHandlerEvent()
self.gagHandler.addInPattern('%fn-into-%in')
self.exited = False
self.hints = {
'find': False,
'throw': False,
'squashed': False,
'boss': False,
'minion': False
}
self.accept(base.JUMP, self.controlKeyPressed)
def destroy(self):
self.toon.showName()
self.ignoreAll()
self.coolDownAfterHitInterval.clearToInitial()
del self.coolDownAfterHitInterval
del self._getMemoSfx
del self._waterCoolerFillSfx
del self._hitByDropSfx
del self._winSfx
self.orthoWalk.stop()
self.orthoWalk.destroy()
del self.orthoWalk
CogdoMazePlayer.destroy(self)
def __initCollisions(self):
collSphere = CollisionSphere(0, 0, 0, Globals.PlayerCollisionRadius)
collSphere.setTangible(0)
self.mazeCollisionName = Globals.LocalPlayerCollisionName
collNode = CollisionNode(self.mazeCollisionName)
collNode.addSolid(collSphere)
collNodePath = self.toon.attachNewNode(collNode)
collNodePath.hide()
handler = CollisionHandlerEvent()
handler.addInPattern('%fn-into-%in')
base.cTrav.addCollider(collNodePath, handler)
self.handler = handler
self._collNodePath = collNodePath
def clearCollisions(self):
self.handler.clear()
def __disableCollisions(self):
self._collNodePath.removeNode()
del self._collNodePath
def _isNearPlayer(self, player):
return self.toon.getDistance(player.toon) <= self._proximityRadius
def update(self, dt):
if self.getCurrentOrNextState() != 'Off':
self._updateCamera(dt)
def _updateCamera(self, dt):
numPlayers = 0.0
for player in self.game.players:
if player != self and player.toon and self._isNearPlayer(player):
numPlayers += 1
d = clamp(
Globals.CameraMinDistance + numPlayers /
(CogdoGameConsts.MaxPlayers - 1) *
(Globals.CameraMaxDistance - Globals.CameraMinDistance),
Globals.CameraMinDistance, Globals.CameraMaxDistance)
self.cameraMgr.setCameraTargetDistance(d)
self.cameraMgr.update(dt)
def enterOff(self):
CogdoMazePlayer.enterOff(self)
def exitOff(self):
CogdoMazePlayer.exitOff(self)
self.toon.hideName()
def enterReady(self):
CogdoMazePlayer.enterReady(self)
self.cameraMgr.enable()
def exitReady(self):
CogdoMazePlayer.enterReady(self)
def enterNormal(self):
CogdoMazePlayer.enterNormal(self)
self.orthoWalk.start()
def exitNormal(self):
CogdoMazePlayer.exitNormal(self)
self.orthoWalk.stop()
def enterHit(self, elapsedTime=0.0):
CogdoMazePlayer.enterHit(self, elapsedTime)
self.setInvulnerable(True)
def exitHit(self):
CogdoMazePlayer.exitHit(self)
self.coolDownAfterHitInterval.clearToInitial()
self.coolDownAfterHitInterval.start()
def enterDone(self):
CogdoMazePlayer.enterDone(self)
self._guiMgr.hideQuestArrow()
self.ignore(base.JUMP)
self._guiMgr.setMessage('')
if self.exited == False:
self.lostMemos()
def exitDone(self):
CogdoMazePlayer.exitDone(self)
def hitByDrop(self):
if self.equippedGag is not None and not self.hints['squashed']:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeSquashHint,
Globals.HintTimeout)
self.hints['squashed'] = True
self._hitByDropSfx.play()
CogdoMazePlayer.hitByDrop(self)
return
def equipGag(self):
CogdoMazePlayer.equipGag(self)
self._waterCoolerFillSfx.play()
messenger.send(Globals.WaterCoolerHideEventName, [])
if not self.hints['throw']:
self._guiMgr.setMessage(TTLocalizer.CogdoMazeThrowHint)
self.hints['throw'] = True
def hitSuit(self, suitType):
if suitType == Globals.SuitTypes.Boss and not self.hints['boss']:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeBossHint,
Globals.HintTimeout)
self.hints['boss'] = True
if suitType != Globals.SuitTypes.Boss and not self.hints['minion']:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeMinionHint,
Globals.HintTimeout)
self.hints['minion'] = True
def createThrowGag(self, gag):
throwGag = CogdoMazePlayer.createThrowGag(self, gag)
collSphere = CollisionSphere(0, 0, 0, 0.5)
collSphere.setTangible(0)
name = Globals.GagCollisionName
collNode = CollisionNode(name)
collNode.setFromCollideMask(ToontownGlobals.PieBitmask)
collNode.addSolid(collSphere)
colNp = throwGag.attachNewNode(collNode)
base.cTrav.addCollider(colNp, self.gagHandler)
return throwGag
def showToonThrowingGag(self, heading, pos):
self._guiMgr.clearMessage()
return CogdoMazePlayer.showToonThrowingGag(self, heading, pos)
def removeGag(self):
if self.equippedGag is None:
return
CogdoMazePlayer.removeGag(self)
self.throwPending = False
messenger.send(Globals.WaterCoolerShowEventName, [])
return
def controlKeyPressed(self):
if self.game.finished or self.throwPending or self.getCurrentOrNextState(
) == 'Hit' or self.equippedGag == None:
return
self.throwPending = True
heading = self.toon.getH()
pos = self.toon.getPos()
self.game.requestUseGag(pos.getX(), pos.getY(), heading)
return
def completeThrow(self):
self.clearCollisions()
CogdoMazePlayer.completeThrow(self)
def shakeCamera(self, strength):
self.cameraMgr.shake(strength)
def getCameraShake(self):
return self.cameraMgr.shakeStrength
def setInvulnerable(self, bool):
self.invulnerable = bool
def handleGameStart(self):
self.numEntered = len(self.game.players)
self.__initCollisions()
self._guiMgr.startGame(TTLocalizer.CogdoMazeFindHint)
self.hints['find'] = True
self.notify.info(
'toonId:%d laff:%d/%d %d player(s) started maze game' %
(self.toon.doId, self.toon.hp, self.toon.maxHp,
len(self.game.players)))
def handleGameExit(self):
self.cameraMgr.disable()
self.__disableCollisions()
def handlePickUp(self, toonId):
if toonId == self.toon.doId:
self.pickupCount += 1
self._guiMgr.setPickupCount(self.pickupCount)
if self.pickupCount == 1:
self._guiMgr.showPickupCounter()
self._getMemoSfx.play()
def handleOpenDoor(self, door):
self._guiMgr.setMessage(TTLocalizer.CogdoMazeGameDoorOpens)
self._guiMgr.showQuestArrow(self.toon, door,
Point3(0, 0,
self.toon.getHeight() + 2))
def handleTimeAlert(self):
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeGameTimeAlert)
def handleToonRevealsDoor(self, toonId, door):
if toonId == self.toon.doId:
self._guiMgr.setMessageTemporary(
TTLocalizer.CogdoMazeGameLocalToonFoundExit)
def handleToonEntersDoor(self, toonId, door):
self.exited = True
message = ''
if door.getPlayerCount() < len(self.game.players):
message = TTLocalizer.WaitingForOtherToons
if toonId == self.toon.doId:
self._guiMgr.setMessage(message)
self._winSfx.play()
self._audioMgr.stopMusic()
self.notify.info(
'toonId:%d laff:%d/%d %d player(s) succeeded in maze game. Going to the executive suit building.'
% (toonId, self.toon.hp, self.toon.maxHp, len(self.game.players)))
if self.numEntered > len(self.game.players):
self.notify.info('%d player(s) failed in maze game' %
(self.numEntered - len(self.game.players)))
def lostMemos(self):
self.pickupCount = 0
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeGameTimeOut)
self._guiMgr.setPickupCount(self.pickupCount)
self.notify.info(
'toonId:%d laff:%d/%d %d player(s) failed in maze game' %
(self.toon.doId, self.toon.hp, self.toon.maxHp,
len(self.game.players)))
class FreeBLiTZ(ShowBase):
def __init__(self):
from pandac.PandaModules import CollisionHandlerFloor, CollisionHandlerPusher, CollisionHandlerEvent, CollisionTraverser
from pandac.PandaModules import DirectionalLight, AmbientLight, VBase4
ShowBase.__init__(self)
self.sky = self.loader.loadModel('models/sky-sphere')
self.sky.reparentTo(self.render)
self.stage = self.loader.loadModel('models/test-collide')
self.stage.reparentTo(self.render)
self.floor = self.stage.findAllMatches('**/=CollideType=floor')
self.floor.setCollideMask(FLOOR_MASK)
self.obstacles = self.stage.findAllMatches('**/=CollideType=obstacle')
if self.obstacles:
self.obstacles.setCollideMask(OBSTACLE_MASK)
self.zones = self.stage.findAllMatches('**/=CollideType=zone')
if self.zones:
self.zones.setCollideMask(ZONE_MASK)
self.create_stanchions()
# Character rig, which allows camera to follow character
self.char_rig = self.stage.attachNewNode('char_rig')
self.active_char = Character('mainchar', self.char_rig)
self.cam.reparentTo(self.char_rig)
self.cam.setPos(0.5, -3, 1.5)
self.cam.lookAt(0.5, 0, 1.5)
self.light = DirectionalLight('dlight')
self.light.setColor(VBase4(0.3, 0.28, 0.26, 1.0))
self.lightNP = self.stage.attachNewNode(self.light)
self.lightNP.setHpr(-75, -45, 0)
self.stage.setLight(self.lightNP)
self.amblight = AmbientLight('amblight')
self.amblight.setColor(VBase4(0.7, 0.68, 0.66, 1.0))
self.amblightNP = self.stage.attachNewNode(self.amblight)
self.stage.setLight(self.amblightNP)
self.accept('w', self.active_char.begin_forward)
self.accept('a', self.active_char.begin_left)
self.accept('s', self.active_char.begin_backward)
self.accept('d', self.active_char.begin_right)
self.accept('w-up', self.active_char.end_forward)
self.accept('a-up', self.active_char.end_left)
self.accept('s-up', self.active_char.end_backward)
self.accept('d-up', self.active_char.end_right)
self.taskMgr.add(self.active_char.MoveTask, 'MoveTask')
self.look = False
self.prev_pos = None
self.accept('mouse2', self.begin_look)
self.accept('mouse2-up', self.end_look)
self.accept('mouse3', self.active_char.begin_spin)
self.accept('mouse3-up', self.active_char.end_spin)
self.taskMgr.add(self.MouseTask, 'MouseTask')
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(self.active_char.actor_from_floor, self.char_rig)
self.wall_handler = CollisionHandlerPusher()
self.wall_handler.addCollider(self.active_char.actor_from_obstacle, self.char_rig)
self.zone_handler = CollisionHandlerEvent()
self.zone_handler.addInPattern('%fn-into')
self.zone_handler.addOutPattern('%fn-out')
def foo(entry):
print 'You are in the zone'
def bar(entry):
print 'You are not in the zone'
self.accept('blockchar_zone-into', foo)
self.accept('blockchar_zone-out', bar)
self.cTrav = CollisionTraverser('main traverser')
self.cTrav.setRespectPrevTransform(True)
self.cTrav.addCollider(self.active_char.actor_from_floor, self.floor_handler)
self.cTrav.addCollider(self.active_char.actor_from_obstacle, self.wall_handler)
self.cTrav.addCollider(self.active_char.actor_from_zone, self.zone_handler)
#self.cTrav.showCollisions(self.stage)
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 begin_look(self):
self.look = True
def end_look(self):
self.look = False
self.prev_pos = None
def MouseTask(self, task):
if self.mouseWatcherNode.hasMouse():
(x, y) = self.mouseWatcherNode.getMouse()
if self.prev_pos:
if self.look or self.active_char.spinning:
h_diff = (x - self.prev_pos[0]) * 180
p_diff = (y - self.prev_pos[1]) * 90
new_h = clamp_deg_sign(self.char_rig.getH() - h_diff)
self.char_rig.setH(new_h)
self.cam.setP(self.cam.getP() + p_diff)
self.active_char.spin(new_h)
self.prev_pos = (x, y)
return task.cont
avatarCollider = avatar.attachNewNode(CollisionNode('yolkycnode'))
avatarCollider.node().addSolid(CollisionSphere(0, 0, 0, 1))
avatarCollider.node().setFromCollideMask(WALL_MASK)
avatarCollider.node().setIntoCollideMask(BitMask32.allOff())
#** the avatar's fallout sensor - stuff already seen in former snippets, but this time we'll use it for more that to detect the fallout impact force, so we'll add another mask to look out
avatarSensor = avatarNP.attachNewNode(CollisionNode('yolkysensor'))
cs = CollisionSphere(0, 0, 0, 1.2)
avatarSensor.node().addSolid(cs)
# here the masking: note that this sensor will look for floor bashing but also for other geometries masked with TRIGGER_MASK.
avatarSensor.node().setFromCollideMask(FLOOR_MASK | TRIGGER_MASK)
avatarSensor.node().setIntoCollideMask(BitMask32.allOff())
cs.setTangible(0)
#** here's how to read the events fired by the 'sensor' while colliding with geometry we enable to collide with it.
collisionEvent.addInPattern('%fn-into')
collisionEvent.addOutPattern('%fn-out')
#** the floor ray collider for the avatar
avatarRay = avatarNP.attachNewNode(CollisionNode('avatarRay'))
avatarRay.node().addSolid(CollisionRay(0, 0, 2, 0, 0, -1))
avatarRay.node().setFromCollideMask(FLOOR_MASK)
avatarRay.node().setIntoCollideMask(BitMask32.allOff())
#** This is the scene map - we'll gather off here almost every element of the map: scenery, ground colliders, walls, and also triggers and spawn points. See the .blend source for details on the scene components.
scene = loader.loadModel("windmill")
scene.reparentTo(render)
scene.setCollideMask(BitMask32.allOff())
scene.setScale(10)
# Let's mask our main collision surfaces
floorcollider = scene.find("**/floor0/floor_collide*")
class CogdoMazeLocalPlayer(CogdoMazePlayer):
notify = directNotify.newCategory('CogdoMazeLocalPlayer')
def __init__(self, id, toon, game, guiMgr):
CogdoMazePlayer.__init__(self, id, toon)
self.disableGagCollision()
self.game = game
self.maze = self.game.maze
self._guiMgr = guiMgr
self.cameraMgr = CogdoMazeCameraManager(self.toon, self.maze, camera, render)
self._proximityRadius = self.maze.cellWidth * Globals.CameraRemoteToonRadius
orthoDrive = OrthoDrive(Globals.ToonRunSpeed, maxFrameMove=self.maze.cellWidth / 2, customCollisionCallback=self.maze.doOrthoCollisions, wantSound=True)
self.orthoWalk = OrthoWalk(orthoDrive)
self._audioMgr = base.cogdoGameAudioMgr
self._getMemoSfx = self._audioMgr.createSfx('getMemo', source=self.toon)
self._waterCoolerFillSfx = self._audioMgr.createSfx('waterCoolerFill', source=self.toon)
self._hitByDropSfx = self._audioMgr.createSfx('toonHitByDrop', source=self.toon)
self._winSfx = self._audioMgr.createSfx('win')
self._loseSfx = self._audioMgr.createSfx('lose')
self.enabled = False
self.pickupCount = 0
self.numEntered = 0
self.throwPending = False
self.coolDownAfterHitInterval = Sequence(Wait(Globals.HitCooldownTime), Func(self.setInvulnerable, False), name='coolDownAfterHitInterval-%i' % self.toon.doId)
self.invulnerable = False
self.gagHandler = CollisionHandlerEvent()
self.gagHandler.addInPattern('%fn-into-%in')
self.exited = False
self.hints = {'find': False,
'throw': False,
'squashed': False,
'boss': False,
'minion': False}
self.accept('control', self.controlKeyPressed)
def destroy(self):
self.toon.showName()
self.ignoreAll()
self.coolDownAfterHitInterval.clearToInitial()
del self.coolDownAfterHitInterval
del self._getMemoSfx
del self._waterCoolerFillSfx
del self._hitByDropSfx
del self._winSfx
self.orthoWalk.stop()
self.orthoWalk.destroy()
del self.orthoWalk
CogdoMazePlayer.destroy(self)
def __initCollisions(self):
collSphere = CollisionSphere(0, 0, 0, Globals.PlayerCollisionRadius)
collSphere.setTangible(0)
self.mazeCollisionName = Globals.LocalPlayerCollisionName
collNode = CollisionNode(self.mazeCollisionName)
collNode.addSolid(collSphere)
collNodePath = self.toon.attachNewNode(collNode)
collNodePath.hide()
handler = CollisionHandlerEvent()
handler.addInPattern('%fn-into-%in')
base.cTrav.addCollider(collNodePath, handler)
self.handler = handler
self._collNodePath = collNodePath
def clearCollisions(self):
self.handler.clear()
def __disableCollisions(self):
self._collNodePath.removeNode()
del self._collNodePath
def _isNearPlayer(self, player):
return self.toon.getDistance(player.toon) <= self._proximityRadius
def update(self, dt):
if self.getCurrentOrNextState() != 'Off':
self._updateCamera(dt)
def _updateCamera(self, dt):
numPlayers = 0.0
for player in self.game.players:
if player != self and player.toon and self._isNearPlayer(player):
numPlayers += 1
d = clamp(Globals.CameraMinDistance + numPlayers / (CogdoGameConsts.MaxPlayers - 1) * (Globals.CameraMaxDistance - Globals.CameraMinDistance), Globals.CameraMinDistance, Globals.CameraMaxDistance)
self.cameraMgr.setCameraTargetDistance(d)
self.cameraMgr.update(dt)
def enterOff(self):
CogdoMazePlayer.enterOff(self)
def exitOff(self):
CogdoMazePlayer.exitOff(self)
self.toon.hideName()
def enterReady(self):
CogdoMazePlayer.enterReady(self)
self.cameraMgr.enable()
def exitReady(self):
CogdoMazePlayer.enterReady(self)
def enterNormal(self):
CogdoMazePlayer.enterNormal(self)
self.orthoWalk.start()
def exitNormal(self):
CogdoMazePlayer.exitNormal(self)
self.orthoWalk.stop()
def enterHit(self, elapsedTime = 0.0):
CogdoMazePlayer.enterHit(self, elapsedTime)
self.setInvulnerable(True)
def exitHit(self):
CogdoMazePlayer.exitHit(self)
self.coolDownAfterHitInterval.clearToInitial()
self.coolDownAfterHitInterval.start()
def enterDone(self):
CogdoMazePlayer.enterDone(self)
self._guiMgr.hideQuestArrow()
self.ignore('control')
self._guiMgr.setMessage('')
if self.exited == False:
self.lostMemos()
def exitDone(self):
CogdoMazePlayer.exitDone(self)
def hitByDrop(self):
if self.equippedGag is not None and not self.hints['squashed']:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeSquashHint, Globals.HintTimeout)
self.hints['squashed'] = True
self._hitByDropSfx.play()
CogdoMazePlayer.hitByDrop(self)
return
def equipGag(self):
CogdoMazePlayer.equipGag(self)
self._waterCoolerFillSfx.play()
messenger.send(Globals.WaterCoolerHideEventName, [])
if not self.hints['throw']:
self._guiMgr.setMessage(TTLocalizer.CogdoMazeThrowHint)
self.hints['throw'] = True
def hitSuit(self, suitType):
if suitType == Globals.SuitTypes.Boss and not self.hints['boss']:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeBossHint, Globals.HintTimeout)
self.hints['boss'] = True
if suitType != Globals.SuitTypes.Boss and not self.hints['minion']:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeMinionHint, Globals.HintTimeout)
self.hints['minion'] = True
def createThrowGag(self, gag):
throwGag = CogdoMazePlayer.createThrowGag(self, gag)
collSphere = CollisionSphere(0, 0, 0, 0.5)
collSphere.setTangible(0)
name = Globals.GagCollisionName
collNode = CollisionNode(name)
collNode.setFromCollideMask(ToontownGlobals.PieBitmask)
collNode.addSolid(collSphere)
colNp = throwGag.attachNewNode(collNode)
base.cTrav.addCollider(colNp, self.gagHandler)
return throwGag
def showToonThrowingGag(self, heading, pos):
self._guiMgr.clearMessage()
return CogdoMazePlayer.showToonThrowingGag(self, heading, pos)
def removeGag(self):
if self.equippedGag is None:
return
CogdoMazePlayer.removeGag(self)
self.throwPending = False
messenger.send(Globals.WaterCoolerShowEventName, [])
return
def controlKeyPressed(self):
if self.game.finished or self.throwPending or self.getCurrentOrNextState() == 'Hit' or self.equippedGag == None:
return
self.throwPending = True
heading = self.toon.getH()
pos = self.toon.getPos()
self.game.requestUseGag(pos.getX(), pos.getY(), heading)
return
def completeThrow(self):
self.clearCollisions()
CogdoMazePlayer.completeThrow(self)
def shakeCamera(self, strength):
self.cameraMgr.shake(strength)
def getCameraShake(self):
return self.cameraMgr.shakeStrength
def setInvulnerable(self, bool):
self.invulnerable = bool
def handleGameStart(self):
self.numEntered = len(self.game.players)
self.__initCollisions()
self._guiMgr.startGame(TTLocalizer.CogdoMazeFindHint)
self.hints['find'] = True
self.notify.info('toonId:%d laff:%d/%d %d player(s) started maze game' % (self.toon.doId,
self.toon.hp,
self.toon.maxHp,
len(self.game.players)))
def handleGameExit(self):
self.cameraMgr.disable()
self.__disableCollisions()
def handlePickUp(self, toonId):
if toonId == self.toon.doId:
self.pickupCount += 1
self._guiMgr.setPickupCount(self.pickupCount)
if self.pickupCount == 1:
self._guiMgr.showPickupCounter()
self._getMemoSfx.play()
def handleOpenDoor(self, door):
self._guiMgr.setMessage(TTLocalizer.CogdoMazeGameDoorOpens)
self._guiMgr.showQuestArrow(self.toon, door, Point3(0, 0, self.toon.getHeight() + 2))
def handleTimeAlert(self):
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeGameTimeAlert)
def handleToonRevealsDoor(self, toonId, door):
if toonId == self.toon.doId:
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeGameLocalToonFoundExit)
def handleToonEntersDoor(self, toonId, door):
self.exited = True
message = ''
if door.getPlayerCount() < len(self.game.players):
message = TTLocalizer.WaitingForOtherToons
if toonId == self.toon.doId:
self._guiMgr.setMessage(message)
self._winSfx.play()
self._audioMgr.stopMusic()
self.notify.info('toonId:%d laff:%d/%d %d player(s) succeeded in maze game. Going to the executive suit building.' % (toonId,
self.toon.hp,
self.toon.maxHp,
len(self.game.players)))
if self.numEntered > len(self.game.players):
self.notify.info('%d player(s) failed in maze game' % (self.numEntered - len(self.game.players)))
def lostMemos(self):
self.pickupCount = 0
self._guiMgr.setMessageTemporary(TTLocalizer.CogdoMazeGameTimeOut)
self._guiMgr.setPickupCount(self.pickupCount)
self.notify.info('toonId:%d laff:%d/%d %d player(s) failed in maze game' % (self.toon.doId,
self.toon.hp,
self.toon.maxHp,
len(self.game.players)))
class DistributedIceGame(DistributedMinigame.DistributedMinigame,
DistributedIceWorld.DistributedIceWorld):
notify = directNotify.newCategory('DistributedIceGame')
MaxLocalForce = 100
MaxPhysicsForce = 25000
def __init__(self, cr):
DistributedMinigame.DistributedMinigame.__init__(self, cr)
DistributedIceWorld.DistributedIceWorld.__init__(self, cr)
self.gameFSM = ClassicFSM.ClassicFSM('DistributedIceGame', [
State.State('off', self.enterOff, self.exitOff, ['inputChoice']),
State.State(
'inputChoice', self.enterInputChoice, self.exitInputChoice,
['waitServerChoices', 'moveTires', 'displayVotes', 'cleanup']),
State.State('waitServerChoices', self.enterWaitServerChoices,
self.exitWaitServerChoices, ['moveTires', 'cleanup']),
State.State('moveTires', self.enterMoveTires, self.exitMoveTires,
['synch', 'cleanup']),
State.State('synch', self.enterSynch, self.exitSynch,
['inputChoice', 'scoring', 'cleanup']),
State.State('scoring', self.enterScoring, self.exitScoring,
['cleanup', 'finalResults', 'inputChoice']),
State.State('finalResults', self.enterFinalResults,
self.exitFinalResults, ['cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])
], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.cameraThreeQuarterView = (0, -22, 45, 0, -62.890000000000001, 0)
self.tireDict = {}
self.forceArrowDict = {}
self.canDrive = False
self.timer = None
self.timerStartTime = None
self.curForce = 0
self.curHeading = 0
self.headingMomentum = 0.0
self.forceMomentum = 0.0
self.allTireInputs = None
self.curRound = 0
self.curMatch = 0
self.controlKeyWarningLabel = DirectLabel(
text=TTLocalizer.IceGameControlKeyWarning,
text_fg=VBase4(1, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0),
scale=0.14999999999999999)
self.controlKeyWarningLabel.hide()
self.waitingMoveLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForPlayersToFinishMove,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingMoveLabel.hide()
self.waitingSyncLabel = DirectLabel(
text=TTLocalizer.IceGameWaitingForAISync,
text_fg=VBase4(1, 1, 1, 1),
relief=None,
pos=(-0.59999999999999998, 0, -0.75),
scale=0.074999999999999997)
self.waitingSyncLabel.hide()
self.infoLabel = DirectLabel(text='',
text_fg=VBase4(0, 0, 0, 1),
relief=None,
pos=(0.0, 0, 0.69999999999999996),
scale=0.074999999999999997)
self.updateInfoLabel()
self.lastForceArrowUpdateTime = 0
self.sendForceArrowUpdateAsap = False
self.treasures = []
self.penalties = []
self.obstacles = []
self.controlKeyPressed = False
self.controlKeyWarningIval = None
def delete(self):
DistributedIceWorld.DistributedIceWorld.delete(self)
DistributedMinigame.DistributedMinigame.delete(self)
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningLabel.destroy()
del self.controlKeyWarningLabel
self.waitingMoveLabel.destroy()
del self.waitingMoveLabel
self.waitingSyncLabel.destroy()
del self.waitingSyncLabel
self.infoLabel.destroy()
del self.infoLabel
for treasure in self.treasures:
treasure.destroy()
del self.treasures
for penalty in self.penalties:
penalty.destroy()
del self.penalties
for obstacle in self.obstacles:
obstacle.removeNode()
del self.obstacles
del self.gameFSM
def announceGenerate(self):
DistributedMinigame.DistributedMinigame.announceGenerate(self)
DistributedIceWorld.DistributedIceWorld.announceGenerate(self)
self.debugTaskName = self.uniqueName('debugTask')
def getTitle(self):
return TTLocalizer.IceGameTitle
def getInstructions(self):
szId = self.getSafezoneId()
numPenalties = IceGameGlobals.NumPenalties[szId]
result = TTLocalizer.IceGameInstructions
if numPenalties == 0:
result = TTLocalizer.IceGameInstructionsNoTnt
return result
def getMaxDuration(self):
return 0
def load(self):
self.notify.debug('load')
DistributedMinigame.DistributedMinigame.load(self)
self.music = base.loadMusic('phase_4/audio/bgm/MG_IceGame.mid')
self.gameBoard = loader.loadModel(
'phase_4/models/minigames/ice_game_icerink')
background = loader.loadModel('phase_4/models/minigames/ice_game_2d')
background.reparentTo(self.gameBoard)
self.gameBoard.setPosHpr(0, 0, 0, 0, 0, 0)
self.gameBoard.setScale(1.0)
self.setupSimulation()
index = 0
for avId in self.avIdList:
self.setupTire(avId, index)
self.setupForceArrow(avId)
index += 1
for index in xrange(len(self.avIdList), 4):
self.setupTire(-index, index)
self.setupForceArrow(-index)
self.showForceArrows(realPlayersOnly=True)
self.westWallModel = NodePath()
if not self.westWallModel.isEmpty():
self.westWallModel.reparentTo(self.gameBoard)
self.westWallModel.setPos(IceGameGlobals.MinWall[0],
IceGameGlobals.MinWall[1], 0)
self.westWallModel.setScale(4)
self.eastWallModel = NodePath()
if not self.eastWallModel.isEmpty():
self.eastWallModel.reparentTo(self.gameBoard)
self.eastWallModel.setPos(IceGameGlobals.MaxWall[0],
IceGameGlobals.MaxWall[1], 0)
self.eastWallModel.setScale(4)
self.eastWallModel.setH(180)
self.arrowKeys = ArrowKeys.ArrowKeys()
self.target = loader.loadModel('phase_3/models/misc/sphere')
self.target.setScale(0.01)
self.target.reparentTo(self.gameBoard)
self.target.setPos(0, 0, 0)
self.scoreCircle = loader.loadModel(
'phase_4/models/minigames/ice_game_score_circle')
self.scoreCircle.setScale(0.01)
self.scoreCircle.reparentTo(self.gameBoard)
self.scoreCircle.setZ(IceGameGlobals.TireRadius / 2.0)
self.scoreCircle.setAlphaScale(0.5)
self.scoreCircle.setTransparency(1)
self.scoreCircle.hide()
self.treasureModel = loader.loadModel(
'phase_4/models/minigames/ice_game_barrel')
self.penaltyModel = loader.loadModel(
'phase_4/models/minigames/ice_game_tnt2')
self.penaltyModel.setScale(0.75, 0.75, 0.69999999999999996)
szId = self.getSafezoneId()
obstacles = IceGameGlobals.Obstacles[szId]
index = 0
cubicObstacle = IceGameGlobals.ObstacleShapes[szId]
for pos in obstacles:
newPos = Point3(pos[0], pos[1], IceGameGlobals.TireRadius)
newObstacle = self.createObstacle(newPos, index, cubicObstacle)
self.obstacles.append(newObstacle)
index += 1
self.countSound = loader.loadSfx(
'phase_3.5/audio/sfx/tick_counter.mp3')
self.treasureGrabSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_vine_game_bananas.mp3')
self.penaltyGrabSound = loader.loadSfx(
'phase_4/audio/sfx/MG_cannon_fire_alt.mp3')
self.tireSounds = []
for tireIndex in xrange(4):
tireHit = loader.loadSfx(
'phase_4/audio/sfx/Golf_Hit_Barrier_1.mp3')
wallHit = loader.loadSfx('phase_4/audio/sfx/MG_maze_pickup.mp3')
obstacleHit = loader.loadSfx(
'phase_4/audio/sfx/Golf_Hit_Barrier_2.mp3')
self.tireSounds.append({
'tireHit': tireHit,
'wallHit': wallHit,
'obstacleHit': obstacleHit
})
self.arrowRotateSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_force_rotate.wav')
self.arrowUpSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_force_increase_3sec.mp3')
self.arrowDownSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_force_decrease_3sec.mp3')
self.scoreCircleSound = loader.loadSfx(
'phase_4/audio/sfx/MG_sfx_ice_scoring_1.mp3')
def unload(self):
self.notify.debug('unload')
DistributedMinigame.DistributedMinigame.unload(self)
del self.music
self.gameBoard.removeNode()
del self.gameBoard
for forceArrow in self.forceArrowDict.values():
forceArrow.removeNode()
del self.forceArrowDict
self.scoreCircle.removeNode()
del self.scoreCircle
del self.countSound
def onstage(self):
self.notify.debug('onstage')
DistributedMinigame.DistributedMinigame.onstage(self)
self.gameBoard.reparentTo(render)
self._DistributedIceGame__placeToon(self.localAvId)
self.moveCameraToTop()
self.scorePanels = []
base.playMusic(self.music, looping=1, volume=0.80000000000000004)
def offstage(self):
self.notify.debug('offstage')
self.music.stop()
self.gameBoard.hide()
self.infoLabel.hide()
for avId in self.tireDict:
self.tireDict[avId]['tireNodePath'].hide()
for panel in self.scorePanels:
panel.cleanup()
del self.scorePanels
for obstacle in self.obstacles:
obstacle.hide()
for treasure in self.treasures:
treasure.nodePath.hide()
for penalty in self.penalties:
penalty.nodePath.hide()
for avId in self.avIdList:
av = self.getAvatar(avId)
if av:
av.dropShadow.show()
av.resetLOD()
continue
taskMgr.remove(self.uniqueName('aimtask'))
self.arrowKeys.destroy()
del self.arrowKeys
DistributedMinigame.DistributedMinigame.offstage(self)
def handleDisabledAvatar(self, avId):
self.notify.debug('handleDisabledAvatar')
self.notify.debug('avatar ' + str(avId) + ' disabled')
DistributedMinigame.DistributedMinigame.handleDisabledAvatar(
self, avId)
def setGameReady(self):
if not self.hasLocalToon:
return None
self.notify.debug('setGameReady')
if DistributedMinigame.DistributedMinigame.setGameReady(self):
return None
for index in xrange(self.numPlayers):
avId = self.avIdList[index]
toon = self.getAvatar(avId)
if toon:
toon.reparentTo(render)
self._DistributedIceGame__placeToon(avId)
toon.forwardSpeed = 0
toon.rotateSpeed = False
toon.dropShadow.hide()
toon.setAnimState('Sit')
if avId in self.tireDict:
tireNp = self.tireDict[avId]['tireNodePath']
toon.reparentTo(tireNp)
toon.setY(1.0)
toon.setZ(-3)
toon.startLookAround()
continue
def setGameStart(self, timestamp):
if not self.hasLocalToon:
return None
self.notify.debug('setGameStart')
DistributedMinigame.DistributedMinigame.setGameStart(self, timestamp)
for avId in self.remoteAvIdList:
toon = self.getAvatar(avId)
if toon:
toon.stopLookAround()
continue
self.scores = [0] * self.numPlayers
spacing = 0.40000000000000002
for i in xrange(self.numPlayers):
avId = self.avIdList[i]
avName = self.getAvatarName(avId)
scorePanel = MinigameAvatarScorePanel.MinigameAvatarScorePanel(
avId, avName)
scorePanel.setScale(0.90000000000000002)
scorePanel.setPos(0.75 - spacing * (self.numPlayers - 1 - i), 0.0,
0.875)
scorePanel.makeTransparent(0.75)
self.scorePanels.append(scorePanel)
self.arrowKeys.setPressHandlers([
self._DistributedIceGame__upArrowPressed,
self._DistributedIceGame__downArrowPressed,
self._DistributedIceGame__leftArrowPressed,
self._DistributedIceGame__rightArrowPressed,
self._DistributedIceGame__controlPressed
])
def isInPlayState(self):
if not self.gameFSM.getCurrentState():
return False
if not self.gameFSM.getCurrentState().getName() == 'play':
return False
return True
def enterOff(self):
self.notify.debug('enterOff')
def exitOff(self):
pass
def enterInputChoice(self):
self.notify.debug('enterInputChoice')
self.forceLocalToonToTire()
self.controlKeyPressed = False
if self.curRound == 0:
self.setupStartOfMatch()
else:
self.notify.debug('self.curRound = %s' % self.curRound)
self.timer = ToontownTimer.ToontownTimer()
self.timer.hide()
if self.timerStartTime != None:
self.startTimer()
self.showForceArrows(realPlayersOnly=True)
self.localForceArrow().setPosHpr(0, 0, -1.0, 0, 0, 0)
self.localForceArrow().reparentTo(self.localTireNp())
self.localForceArrow().setY(IceGameGlobals.TireRadius)
self.localTireNp().headsUp(self.target)
self.notify.debug('self.localForceArrow() heading = %s' %
self.localForceArrow().getH())
self.curHeading = self.localTireNp().getH()
self.curForce = 25
self.updateLocalForceArrow()
for avId in self.forceArrowDict:
forceArrow = self.forceArrowDict[avId]
forceArrow.setPosHpr(0, 0, -1.0, 0, 0, 0)
tireNp = self.tireDict[avId]['tireNodePath']
forceArrow.reparentTo(tireNp)
forceArrow.setY(IceGameGlobals.TireRadius)
tireNp.headsUp(self.target)
self.updateForceArrow(avId, tireNp.getH(), 25)
taskMgr.add(self._DistributedIceGame__aimTask,
self.uniqueName('aimtask'))
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.stop()
self.sendForceArrowUpdateAsap = False
def exitInputChoice(self):
if not self.controlKeyPressed:
if self.controlKeyWarningIval:
self.controlKeyWarningIval.finish()
self.controlKeyWarningIval = None
self.controlKeyWarningIval = Sequence(
Func(self.controlKeyWarningLabel.show),
self.controlKeyWarningLabel.colorScaleInterval(
10, VBase4(1, 1, 1, 0), startColorScale=VBase4(1, 1, 1,
1)),
Func(self.controlKeyWarningLabel.hide))
self.controlKeyWarningIval.start()
if self.timer != None:
self.timer.destroy()
self.timer = None
self.timerStartTime = None
self.hideForceArrows()
self.arrowRotateSound.stop()
self.arrowUpSound.stop()
self.arrowDownSound.stop()
taskMgr.remove(self.uniqueName('aimtask'))
def enterWaitServerChoices(self):
self.waitingMoveLabel.show()
self.showForceArrows(True)
def exitWaitServerChoices(self):
self.waitingMoveLabel.hide()
self.hideForceArrows()
def enterMoveTires(self):
for key in self.tireDict:
body = self.tireDict[key]['tireBody']
body.setAngularVel(0, 0, 0)
body.setLinearVel(0, 0, 0)
for index in xrange(len(self.allTireInputs)):
input = self.allTireInputs[index]
avId = self.avIdList[index]
body = self.getTireBody(avId)
degs = input[1] + 90
tireNp = self.getTireNp(avId)
tireH = tireNp.getH()
self.notify.debug('tireH = %s' % tireH)
radAngle = deg2Rad(degs)
foo = NodePath('foo')
dirVector = Vec3(math.cos(radAngle), math.sin(radAngle), 0)
self.notify.debug('dirVector is now=%s' % dirVector)
inputForce = input[0]
inputForce /= self.MaxLocalForce
inputForce *= self.MaxPhysicsForce
force = dirVector * inputForce
self.notify.debug('adding force %s to %d' % (force, avId))
body.addForce(force)
self.enableAllTireBodies()
self.totalPhysicsSteps = 0
self.startSim()
taskMgr.add(self._DistributedIceGame__moveTiresTask,
self.uniqueName('moveTiresTtask'))
def exitMoveTires(self):
self.forceLocalToonToTire()
self.disableAllTireBodies()
self.stopSim()
self.notify.debug('total Physics steps = %d' % self.totalPhysicsSteps)
taskMgr.remove(self.uniqueName('moveTiresTtask'))
def enterSynch(self):
self.waitingSyncLabel.show()
def exitSynch(self):
self.waitingSyncLabel.hide()
def enterScoring(self):
sortedByDistance = []
for avId in self.avIdList:
np = self.getTireNp(avId)
pos = np.getPos()
pos.setZ(0)
sortedByDistance.append((avId, pos.length()))
def compareDistance(x, y):
if x[1] - y[1] > 0:
return 1
elif x[1] - y[1] < 0:
return -1
else:
return 0
sortedByDistance.sort(cmp=compareDistance)
self.scoreMovie = Sequence()
curScale = 0.01
curTime = 0
self.scoreCircle.setScale(0.01)
self.scoreCircle.show()
self.notify.debug('newScores = %s' % self.newScores)
circleStartTime = 0
for index in xrange(len(sortedByDistance)):
distance = sortedByDistance[index][1]
avId = sortedByDistance[index][0]
scorePanelIndex = self.avIdList.index(avId)
time = (distance - curScale) / IceGameGlobals.ExpandFeetPerSec
if time < 0:
time = 0.01
scaleXY = distance + IceGameGlobals.TireRadius
self.notify.debug('circleStartTime = %s' % circleStartTime)
self.scoreMovie.append(
Parallel(
LerpScaleInterval(self.scoreCircle, time,
Point3(scaleXY, scaleXY, 1.0)),
SoundInterval(self.scoreCircleSound,
duration=time,
startTime=circleStartTime)))
circleStartTime += time
startScore = self.scorePanels[scorePanelIndex].getScore()
destScore = self.newScores[scorePanelIndex]
self.notify.debug('for avId %d, startScore=%d, newScores=%d' %
(avId, startScore, destScore))
def increaseScores(t,
scorePanelIndex=scorePanelIndex,
startScore=startScore,
destScore=destScore):
oldScore = self.scorePanels[scorePanelIndex].getScore()
diff = destScore - startScore
newScore = int(startScore + diff * t)
if newScore > oldScore:
base.playSfx(self.countSound)
self.scorePanels[scorePanelIndex].setScore(newScore)
self.scores[scorePanelIndex] = newScore
duration = (destScore -
startScore) * IceGameGlobals.ScoreCountUpRate
tireNp = self.tireDict[avId]['tireNodePath']
self.scoreMovie.append(
Parallel(
LerpFunctionInterval(increaseScores, duration),
Sequence(
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 0, 0, 1)),
LerpColorScaleInterval(tireNp, duration / 6.0,
VBase4(1, 1, 1, 1)))))
curScale += distance
self.scoreMovie.append(
Func(self.sendUpdate, 'reportScoringMovieDone', []))
self.scoreMovie.start()
def exitScoring(self):
self.scoreMovie.finish()
self.scoreMovie = None
self.scoreCircle.hide()
def enterFinalResults(self):
lerpTrack = Parallel()
lerpDur = 0.5
tY = 0.59999999999999998
bY = -0.050000000000000003
lX = -0.5
cX = 0
rX = 0.5
scorePanelLocs = (((cX, bY), ), ((lX, bY), (rX, bY)),
((cX, tY), (lX, bY), (rX, bY)), ((lX, tY), (rX, tY),
(lX, bY), (rX, bY)))
scorePanelLocs = scorePanelLocs[self.numPlayers - 1]
for i in xrange(self.numPlayers):
panel = self.scorePanels[i]
pos = scorePanelLocs[i]
lerpTrack.append(
Parallel(
LerpPosInterval(panel,
lerpDur,
Point3(pos[0], 0, pos[1]),
blendType='easeInOut'),
LerpScaleInterval(panel,
lerpDur,
Vec3(panel.getScale()) * 2.0,
blendType='easeInOut')))
self.showScoreTrack = Parallel(
lerpTrack,
Sequence(Wait(IceGameGlobals.ShowScoresDuration),
Func(self.gameOver)))
self.showScoreTrack.start()
def exitFinalResults(self):
self.showScoreTrack.pause()
del self.showScoreTrack
def enterCleanup(self):
self.notify.debug('enterCleanup')
if base.localAvatar.laffMeter:
base.localAvatar.laffMeter.start()
def exitCleanup(self):
pass
def _DistributedIceGame__placeToon(self, avId):
toon = self.getAvatar(avId)
if toon:
toon.setPos(0, 0, 0)
toon.setHpr(0, 0, 0)
def moveCameraToTop(self):
camera.reparentTo(render)
p = self.cameraThreeQuarterView
camera.setPosHpr(p[0], p[1], p[2], p[3], p[4], p[5])
def setupTire(self, avId, index):
(tireNp, tireBody, tireOdeGeom) = self.createTire(index)
self.tireDict[avId] = {
'tireNodePath': tireNp,
'tireBody': tireBody,
'tireOdeGeom': tireOdeGeom
}
if avId <= 0:
tireBlocker = tireNp.find('**/tireblockermesh')
if not tireBlocker.isEmpty():
tireBlocker.hide()
if avId == self.localAvId:
tireNp = self.tireDict[avId]['tireNodePath']
self.treasureSphereName = 'treasureCollider'
self.treasureCollSphere = CollisionSphere(
0, 0, 0, IceGameGlobals.TireRadius)
self.treasureCollSphere.setTangible(0)
self.treasureCollNode = CollisionNode(self.treasureSphereName)
self.treasureCollNode.setFromCollideMask(
ToontownGlobals.PieBitmask)
self.treasureCollNode.addSolid(self.treasureCollSphere)
self.treasureCollNodePath = tireNp.attachNewNode(
self.treasureCollNode)
self.treasureHandler = CollisionHandlerEvent()
self.treasureHandler.addInPattern('%fn-intoTreasure')
base.cTrav.addCollider(self.treasureCollNodePath,
self.treasureHandler)
eventName = '%s-intoTreasure' % self.treasureCollNodePath.getName()
self.notify.debug('eventName = %s' % eventName)
self.accept(eventName, self.toonHitSomething)
def setupForceArrow(self, avId):
arrow = loader.loadModel('phase_4/models/minigames/ice_game_arrow')
priority = 0
if avId < 0:
priority = -avId
else:
priority = self.avIdList.index(avId)
if avId == self.localAvId:
priority = 10
self.forceArrowDict[avId] = arrow
def hideForceArrows(self):
for forceArrow in self.forceArrowDict.values():
forceArrow.hide()
def showForceArrows(self, realPlayersOnly=True):
for avId in self.forceArrowDict:
if realPlayersOnly:
if avId > 0:
self.forceArrowDict[avId].show()
else:
self.forceArrowDict[avId].hide()
avId > 0
self.forceArrowDict[avId].show()
def localForceArrow(self):
if self.localAvId in self.forceArrowDict:
return self.forceArrowDict[self.localAvId]
else:
return None
def setChoices(self, input0, input1, input2, input3):
pass
def startDebugTask(self):
taskMgr.add(self.debugTask, self.debugTaskName)
def stopDebugTask(self):
taskMgr.remove(self.debugTaskName)
def debugTask(self, task):
if self.canDrive and self.tireDict.has_key(localAvatar.doId):
dt = globalClock.getDt()
forceMove = 25000
forceMoveDt = forceMove
tireBody = self.tireDict[localAvatar.doId]['tireBody']
if self.arrowKeys.upPressed() and not tireBody.isEnabled():
x = 0
y = 1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.downPressed() and not tireBody.isEnabled():
x = 0
y = -1
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.leftPressed() and not tireBody.isEnabled():
x = -1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
if self.arrowKeys.rightPressed() and not tireBody.isEnabled():
x = 1
y = 0
tireBody.enable()
tireBody.addForce(Vec3(x * forceMoveDt, y * forceMoveDt, 0))
return task.cont
def _DistributedIceGame__upArrowPressed(self):
pass
def _DistributedIceGame__downArrowPressed(self):
pass
def _DistributedIceGame__leftArrowPressed(self):
pass
def _DistributedIceGame__rightArrowPressed(self):
pass
def _DistributedIceGame__controlPressed(self):
if self.gameFSM.getCurrentState().getName() == 'inputChoice':
self.sendForceArrowUpdateAsap = True
self.updateLocalForceArrow()
self.controlKeyPressed = True
self.sendUpdate('setAvatarChoice',
[self.curForce, self.curHeading])
self.gameFSM.request('waitServerChoices')
def startTimer(self):
now = globalClock.getFrameTime()
elapsed = now - self.timerStartTime
self.timer.posInTopRightCorner()
self.timer.setTime(IceGameGlobals.InputTimeout)
self.timer.countdown(IceGameGlobals.InputTimeout - elapsed,
self.handleChoiceTimeout)
self.timer.show()
def setTimerStartTime(self, timestamp):
if not self.hasLocalToon:
return None
self.timerStartTime = globalClockDelta.networkToLocalTime(timestamp)
if self.timer != None:
self.startTimer()
def handleChoiceTimeout(self):
self.sendUpdate('setAvatarChoice', [0, 0])
self.gameFSM.request('waitServerChoices')
def localTireNp(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]['tireNodePath']
return ret
def localTireBody(self):
ret = None
if self.localAvId in self.tireDict:
ret = self.tireDict[self.localAvId]['tireBody']
return ret
def getTireBody(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]['tireBody']
return ret
def getTireNp(self, avId):
ret = None
if avId in self.tireDict:
ret = self.tireDict[avId]['tireNodePath']
return ret
def updateForceArrow(self, avId, curHeading, curForce):
forceArrow = self.forceArrowDict[avId]
tireNp = self.tireDict[avId]['tireNodePath']
tireNp.setH(curHeading)
tireBody = self.tireDict[avId]['tireBody']
tireBody.setQuaternion(tireNp.getQuat())
self.notify.debug('curHeading = %s' % curHeading)
yScale = curForce / 100.0
yScale *= 1
headY = yScale * 15
xScale = (yScale - 1) / 2.0 + 1.0
shaft = forceArrow.find('**/arrow_shaft')
head = forceArrow.find('**/arrow_head')
shaft.setScale(xScale, yScale, 1)
head.setPos(0, headY, 0)
head.setScale(xScale, xScale, 1)
def updateLocalForceArrow(self):
avId = self.localAvId
self.b_setForceArrowInfo(avId, self.curHeading, self.curForce)
def _DistributedIceGame__aimTask(self, task):
if not hasattr(self, 'arrowKeys'):
return task.done
dt = globalClock.getDt()
headingMomentumChange = dt * 60.0
forceMomentumChange = dt * 160.0
arrowUpdate = False
arrowRotating = False
arrowUp = False
arrowDown = False
if self.arrowKeys.upPressed() and not self.arrowKeys.downPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce += self.forceMomentum * dt
arrowUpdate = True
if oldForce < self.MaxLocalForce:
arrowUp = True
elif self.arrowKeys.downPressed() and not self.arrowKeys.upPressed():
self.forceMomentum += forceMomentumChange
if self.forceMomentum < 0:
self.forceMomentum = 0
if self.forceMomentum > 50:
self.forceMomentum = 50
oldForce = self.curForce
self.curForce -= self.forceMomentum * dt
arrowUpdate = True
if oldForce > 0.01:
arrowDown = True
else:
self.forceMomentum = 0
if self.arrowKeys.leftPressed() and not self.arrowKeys.rightPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading += self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
elif self.arrowKeys.rightPressed(
) and not self.arrowKeys.leftPressed():
self.headingMomentum += headingMomentumChange
if self.headingMomentum < 0:
self.headingMomentum = 0
if self.headingMomentum > 50:
self.headingMomentum = 50
self.curHeading -= self.headingMomentum * dt
arrowUpdate = True
arrowRotating = True
else:
self.headingMomentum = 0
if arrowUpdate:
self.normalizeHeadingAndForce()
self.updateLocalForceArrow()
if arrowRotating:
if not self.arrowRotateSound.status(
) == self.arrowRotateSound.PLAYING:
base.playSfx(self.arrowRotateSound, looping=True)
else:
self.arrowRotateSound.stop()
if arrowUp:
if not self.arrowUpSound.status() == self.arrowUpSound.PLAYING:
base.playSfx(self.arrowUpSound, looping=False)
else:
self.arrowUpSound.stop()
if arrowDown:
if not self.arrowDownSound.status() == self.arrowDownSound.PLAYING:
base.playSfx(self.arrowDownSound, looping=False)
else:
self.arrowDownSound.stop()
return task.cont
def normalizeHeadingAndForce(self):
if self.curForce > self.MaxLocalForce:
self.curForce = self.MaxLocalForce
if self.curForce < 0.01:
self.curForce = 0.01
def setTireInputs(self, tireInputs):
if not self.hasLocalToon:
return None
self.allTireInputs = tireInputs
self.gameFSM.request('moveTires')
def enableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]['tireBody'].enable()
def disableAllTireBodies(self):
for avId in self.tireDict.keys():
self.tireDict[avId]['tireBody'].disable()
def areAllTiresDisabled(self):
for avId in self.tireDict.keys():
if self.tireDict[avId]['tireBody'].isEnabled():
return False
continue
return True
def _DistributedIceGame__moveTiresTask(self, task):
if self.areAllTiresDisabled():
self.sendTirePositions()
self.gameFSM.request('synch')
return task.done
return task.cont
def sendTirePositions(self):
tirePositions = []
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
pos = Point3(tire.getPosition())
tirePositions.append([pos[0], pos[1], pos[2]])
self.sendUpdate('endingPositions', [tirePositions])
def setFinalPositions(self, finalPos):
if not self.hasLocalToon:
return None
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
for index in xrange(len(self.avIdList), 4):
avId = -index
tire = self.getTireBody(avId)
np = self.getTireNp(avId)
pos = finalPos[index]
tire.setPosition(pos[0], pos[1], pos[2])
np.setPos(pos[0], pos[1], pos[2])
def updateInfoLabel(self):
self.infoLabel['text'] = TTLocalizer.IceGameInfo % {
'curMatch': self.curMatch + 1,
'numMatch': IceGameGlobals.NumMatches,
'curRound': self.curRound + 1,
'numRound': IceGameGlobals.NumRounds
}
def setMatchAndRound(self, match, round):
if not self.hasLocalToon:
return None
self.curMatch = match
self.curRound = round
self.updateInfoLabel()
def setScores(self, match, round, scores):
if not self.hasLocalToon:
return None
self.newMatch = match
self.newRound = round
self.newScores = scores
def setNewState(self, state):
if not self.hasLocalToon:
return None
self.notify.debug('setNewState gameFSM=%s newState=%s' %
(self.gameFSM, state))
self.gameFSM.request(state)
def putAllTiresInStartingPositions(self):
for index in xrange(len(self.avIdList)):
avId = self.avIdList[index]
np = self.tireDict[avId]['tireNodePath']
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug('avId=%s newPos=%s' % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]['tireBody']
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
for index in xrange(len(self.avIdList), 4):
avId = -index
np = self.tireDict[avId]['tireNodePath']
np.setPos(IceGameGlobals.StartingPositions[index])
self.notify.debug('avId=%s newPos=%s' % (avId, np.getPos))
np.setHpr(0, 0, 0)
quat = np.getQuat()
body = self.tireDict[avId]['tireBody']
body.setPosition(IceGameGlobals.StartingPositions[index])
body.setQuaternion(quat)
def b_setForceArrowInfo(self, avId, force, heading):
self.setForceArrowInfo(avId, force, heading)
self.d_setForceArrowInfo(avId, force, heading)
def d_setForceArrowInfo(self, avId, force, heading):
sendIt = False
curTime = self.getCurrentGameTime()
if self.sendForceArrowUpdateAsap:
sendIt = True
elif curTime - self.lastForceArrowUpdateTime > 0.20000000000000001:
sendIt = True
if sendIt:
self.sendUpdate('setForceArrowInfo', [avId, force, heading])
self.sendForceArrowUpdateAsap = False
self.lastForceArrowUpdateTime = self.getCurrentGameTime()
def setForceArrowInfo(self, avId, force, heading):
if not self.hasLocalToon:
return None
self.updateForceArrow(avId, force, heading)
def setupStartOfMatch(self):
self.putAllTiresInStartingPositions()
szId = self.getSafezoneId()
self.numTreasures = IceGameGlobals.NumTreasures[szId]
if self.treasures:
for treasure in self.treasures:
treasure.destroy()
self.treasures = []
index = 0
treasureMargin = IceGameGlobals.TireRadius + 1.0
while len(self.treasures) < self.numTreasures:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5,
IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5,
IceGameGlobals.MaxWall[1] - 5)
self.notify.debug('yPos=%s' % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newTreasure = IceTreasure.IceTreasure(self.treasureModel,
pos,
index,
self.doId,
penalty=False)
goodSpot = True
for obstacle in self.obstacles:
if newTreasure.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
for treasure in self.treasures:
if newTreasure.nodePath.getDistance(
treasure.nodePath) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
self.treasures.append(newTreasure)
index += 1
continue
newTreasure.destroy()
self.numPenalties = IceGameGlobals.NumPenalties[szId]
if self.penalties:
for penalty in self.penalties:
penalty.destroy()
self.penalties = []
index = 0
while len(self.penalties) < self.numPenalties:
xPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[0] + 5,
IceGameGlobals.MaxWall[0] - 5)
yPos = self.randomNumGen.randrange(IceGameGlobals.MinWall[1] + 5,
IceGameGlobals.MaxWall[1] - 5)
self.notify.debug('yPos=%s' % yPos)
pos = Point3(xPos, yPos, IceGameGlobals.TireRadius)
newPenalty = IceTreasure.IceTreasure(self.penaltyModel,
pos,
index,
self.doId,
penalty=True)
goodSpot = True
for obstacle in self.obstacles:
if newPenalty.nodePath.getDistance(obstacle) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
for treasure in self.treasures:
if newPenalty.nodePath.getDistance(
treasure.nodePath) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
for penalty in self.penalties:
if newPenalty.nodePath.getDistance(
penalty.nodePath) < treasureMargin:
goodSpot = False
break
continue
if goodSpot:
self.penalties.append(newPenalty)
index += 1
continue
newPenalty.destroy()
def toonHitSomething(self, entry):
self.notify.debug('---- treasure Enter ---- ')
self.notify.debug('%s' % entry)
name = entry.getIntoNodePath().getName()
parts = name.split('-')
if len(parts) < 3:
self.notify.debug('collided with %s, but returning' % name)
return None
if not int(parts[1]) == self.doId:
self.notify.debug("collided with %s, but doId doesn't match" %
name)
return None
treasureNum = int(parts[2])
if 'penalty' in parts[0]:
self._DistributedIceGame__penaltyGrabbed(treasureNum)
else:
self._DistributedIceGame__treasureGrabbed(treasureNum)
def _DistributedIceGame__treasureGrabbed(self, treasureNum):
self.treasures[treasureNum].showGrab()
self.treasureGrabSound.play()
self.sendUpdate('claimTreasure', [treasureNum])
def setTreasureGrabbed(self, avId, treasureNum):
if not self.hasLocalToon:
return None
self.notify.debug('treasure %s grabbed by %s' % (treasureNum, avId))
if avId != self.localAvId:
self.treasures[treasureNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] += 1
self.scorePanels[i].setScore(self.scores[i])
def _DistributedIceGame__penaltyGrabbed(self, penaltyNum):
self.penalties[penaltyNum].showGrab()
self.sendUpdate('claimPenalty', [penaltyNum])
def setPenaltyGrabbed(self, avId, penaltyNum):
if not self.hasLocalToon:
return None
self.notify.debug('penalty %s grabbed by %s' % (penaltyNum, avId))
if avId != self.localAvId:
self.penalties[penaltyNum].showGrab()
i = self.avIdList.index(avId)
self.scores[i] -= 1
self.scorePanels[i].setScore(self.scores[i])
def postStep(self):
DistributedIceWorld.DistributedIceWorld.postStep(self)
for count in range(self.colCount):
(c0, c1) = self.getOrderedContacts(count)
if c1 in self.tireCollideIds:
tireIndex = self.tireCollideIds.index(c1)
if c0 in self.tireCollideIds:
self.tireSounds[tireIndex]['tireHit'].play()
elif c0 == self.wallCollideId:
self.tireSounds[tireIndex]['wallHit'].play()
elif c0 == self.obstacleCollideId:
self.tireSounds[tireIndex]['obstacleHit'].play()
c0 in self.tireCollideIds
def forceLocalToonToTire(self):
toon = localAvatar
if toon and self.localAvId in self.tireDict:
tireNp = self.tireDict[self.localAvId]['tireNodePath']
toon.reparentTo(tireNp)
toon.setPosHpr(0, 0, 0, 0, 0, 0)
toon.setY(1.0)
toon.setZ(-3)
class Game(DirectObject.DirectObject):
def __init__(self, showbase, usersData, gameData):
self.showbase = showbase
self.usersData = usersData
self.gameData = gameData
random.seed(self.gameData.randSeed)
# Initialize the collision traverser.
self.cTrav = CollisionTraverser()
# Initialize the handler.
self.collHandEvent = CollisionHandlerEvent()
self.collHandEvent.addInPattern('into-%in')
self.world = World(showbase)
for user in self.usersData:
user.centipede = Centipede(showbase, len(self.usersData),
self.addToCollisions)
if user.thisPlayer:
self.centipede = user.centipede
self.centipede.attachRing(showbase)
self.foods = []
for i in range(self.gameData.maxFoods):
self.foods.append(Food(self.showbase, i, self.addToCollisions))
self.ticks = 0
def destroy(self):
self.world.destroy()
for user in self.usersData:
user.centipede.destroy()
for food in self.foods:
food.destroy()
def runTick(self, dt):
# run each of the centipedes simulations
for user in self.usersData:
user.centipede.update(dt)
if len(user.centipede.body) > 10:
return False
for food in self.foods:
food.update(dt)
self.cTrav.traverse(self.showbase.render)
self.ticks += 1
# Return true if game is still not over (false to end game)
return True
def collideInto(self, collEntry):
for user in self.usersData:
if collEntry.getFromNodePath(
) == user.centipede.head.collisionNode[0]:
for food in self.foods:
if collEntry.getIntoNodePath(
) == food.model.collisionNode[0]:
user.centipede.addLength(self.showbase)
food.reset()
if len(user.centipede.body) > 2:
if collEntry.getIntoNodePath(
) == user.centipede.tail.collisionNode[0]:
user.centipede.reset()
for i in range(len(user.centipede.body) - 1 - 2):
if collEntry.getIntoNodePath() == user.centipede.body[
i + 2].collisionNode[0]:
user.centipede.reset()
break
def addToCollisions(self, item):
# Add this object to the traverser.
self.cTrav.addCollider(item[0], self.collHandEvent)
# Accept the events sent by the collisions.
self.accept('into-' + str(item[1]), self.collideInto)
