from panda3d.core import * from toontown.toonbase.ToonBaseGlobal import * from toontown.toonbase import ToontownGlobals from direct.distributed.ClockDelta import * from direct.interval.IntervalGlobal import * from direct.fsm import ClassicFSM, State from direct.fsm import State from toontown.toonbase import ToontownGlobals from toontown.toonbase import ToontownTimer from direct.task.Task import Task from toontown.minigame import Trajectory import math from toontown.toon import ToonHead from toontown.effects import Splash from toontown.effects import DustCloud from toontown.minigame import CannonGameGlobals import CannonGlobals from direct.gui.DirectGui import * from toontown.toonbase import TTLocalizer from direct.distributed import DistributedObject from toontown.effects import Wake from direct.controls.ControlManager import CollisionHandlerRayStart from toontown.nametag.NametagFloat3d import NametagFloat3d from toontown.nametag.Nametag import Nametag LAND_TIME = 2 WORLD_SCALE = 2.0 GROUND_SCALE = 1.4 * WORLD_SCALE CANNON_SCALE = 1.0 FAR_PLANE_DIST = 600 * WORLD_SCALE GROUND_PLANE_MIN = -15 CANNON_Y = -int(CannonGameGlobals.TowerYRange / 2 * 1.3) CANNON_X_SPACING = 12 CANNON_Z = 20 CANNON_ROTATION_MIN = -55 CANNON_ROTATION_MAX = 50 CANNON_ROTATION_VEL = 15.0 CANNON_ANGLE_MIN = 15 CANNON_ANGLE_MAX = 85 CANNON_ANGLE_VEL = 15.0 CANNON_MOVE_UPDATE_FREQ = 0.5 CAMERA_PULLBACK_MIN = 20 CAMERA_PULLBACK_MAX = 40 MAX_LOOKAT_OFFSET = 80 TOON_TOWER_THRESHOLD = 150 SHADOW_Z_OFFSET = 0.5 TOWER_HEIGHT = 43.85 TOWER_RADIUS = 10.5 BUCKET_HEIGHT = 36 TOWER_Y_RANGE = CannonGameGlobals.TowerYRange TOWER_X_RANGE = int(TOWER_Y_RANGE / 2.0) INITIAL_VELOCITY = 80.0 WHISTLE_SPEED = INITIAL_VELOCITY * 0.35 class DistributedCannon(DistributedObject.DistributedObject): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedCannon') font = ToontownGlobals.getToonFont() LOCAL_CANNON_MOVE_TASK = 'localCannonMoveTask' REWARD_COUNTDOWN_TASK = 'cannonGameRewardCountdown' HIT_GROUND = 0 HIT_TOWER = 1 HIT_WATER = 2 FIRE_KEY = 'control' UP_KEY = 'arrow_up' DOWN_KEY = 'arrow_down' LEFT_KEY = 'arrow_left' RIGHT_KEY = 'arrow_right' BUMPER_KEY = 'delete' BUMPER_KEY2 = 'insert' INTRO_TASK_NAME = 'CannonGameIntro' INTRO_TASK_NAME_CAMERA_LERP = 'CannonGameIntroCamera' def __init__(self, cr): DistributedObject.DistributedObject.__init__(self, cr) self.avId = 0 self.av = None self.localToonShooting = 0 self.nodePath = None self.collSphere = None self.collNode = None self.collNodePath = None self.madeGui = 0 self.gui = None self.cannonLocation = None self.cannonPosition = None self.cannon = None self.toonModel = None self.shadowNode = None self.toonHead = None self.toonScale = None self.estateId = None self.targetId = None self.splash = None self.dustCloud = None self.model_Created = 0 self.lastWakeTime = 0 self.leftPressed = 0 self.rightPressed = 0 self.upPressed = 0 self.downPressed = 0 self.hitBumper = 0 self.hitTarget = 0 self.lastPos = Vec3(0, 0, 0) self.lastVel = Vec3(0, 0, 0) self.vel = Vec3(0, 0, 0) self.landingPos = Vec3(0, 0, 0) self.t = 0 self.lastT = 0 self.deltaT = 0 self.hitTrack = None self.cTrav = None self.cRay = None self.cRayNode = None self.cRayNodePath = None self.lifter = None self.flyColNode = None self.flyColNodePath = None self.bumperCol = None self.cannonMoving = 0 self.inWater = 0 self.localAvId = base.localAvatar.doId self.nextState = None self.nextKey = None self.cannonsActive = 0 self.codeFSM = ClassicFSM.ClassicFSM('CannonCode', [State.State('init', self.enterInit, self.exitInit, ['u1', 'init']), State.State('u1', self.enteru1, self.exitu1, ['u2', 'init']), State.State('u2', self.enteru2, self.exitu2, ['d3', 'init']), State.State('d3', self.enterd3, self.exitd3, ['d4', 'init']), State.State('d4', self.enterd4, self.exitd4, ['l5', 'init']), State.State('l5', self.enterl5, self.exitl5, ['r6', 'init']), State.State('r6', self.enterr6, self.exitr6, ['l7', 'init']), State.State('l7', self.enterl7, self.exitl7, ['r8', 'init']), State.State('r8', self.enterr8, self.exitr8, ['acceptCode', 'init']), State.State('acceptCode', self.enterAcceptCode, self.exitAcceptCode, ['init', 'final']), State.State('final', self.enterFinal, self.exitFinal, [])], 'init', 'final') self.codeFSM.enterInitialState() self.curPinballScore = 0 self.curPinballMultiplier = 1 return def disable(self): self.__unmakeGui() taskMgr.remove(self.taskNameFireCannon) taskMgr.remove(self.taskNameShoot) taskMgr.remove(self.taskNameFly) taskMgr.remove(self.taskNameSmoke) self.ignoreAll() self.setMovie(CannonGlobals.CANNON_MOVIE_CLEAR, 0) self.nodePath.detachNode() if self.hitTrack: self.hitTrack.finish() del self.hitTrack self.hitTrack = None DistributedObject.DistributedObject.disable(self) return def __unmakeGui(self): if not self.madeGui: return self.aimPad.destroy() del self.aimPad del self.fireButton del self.upButton del self.downButton del self.leftButton del self.rightButton self.madeGui = 0 def generateInit(self): DistributedObject.DistributedObject.generateInit(self) self.taskNameFireCannon = self.taskName('fireCannon') self.taskNameShoot = self.taskName('shootTask') self.taskNameSmoke = self.taskName('smokeTask') self.taskNameFly = self.taskName('flyTask') self.nodePath = NodePath(self.uniqueName('Cannon')) self.load() self.activateCannons() self.listenForCode() def listenForCode(self): self.accept(self.UP_KEY + '-up', self.__upKeyCode) self.accept(self.DOWN_KEY + '-up', self.__downKeyCode) self.accept(self.LEFT_KEY + '-up', self.__leftKeyCode) self.accept(self.RIGHT_KEY + '-up', self.__rightKeyCode) def ignoreCode(self): self.ignore(self.UP_KEY + '-up') self.ignore(self.DOWN_KEY + '-up') self.ignore(self.LEFT_KEY + '-up') self.ignore(self.RIGHT_KEY + '-up') def activateCannons(self): if not self.cannonsActive: self.cannonsActive = 1 self.onstage() self.nodePath.reparentTo(self.getParentNodePath()) self.accept(self.uniqueName('enterCannonSphere'), self.__handleEnterSphere) def deActivateCannons(self): if self.cannonsActive: self.cannonsActive = 0 self.offstage() self.nodePath.reparentTo(hidden) self.ignore(self.uniqueName('enterCannonSphere')) def delete(self): self.offstage() self.unload() DistributedObject.DistributedObject.delete(self) def __handleEnterSphere(self, collEntry): self.notify.debug('collEntry: %s' % collEntry) base.cr.playGame.getPlace().setState('fishing') self.d_requestEnter() def d_requestEnter(self): self.sendUpdate('requestEnter', []) def requestExit(self): self.notify.debug('requestExit') base.localAvatar.reparentTo(render) base.cr.playGame.getPlace().setState('walk') def getSphereRadius(self): return 1.5 def getParentNodePath(self): return base.cr.playGame.hood.loader.geom def setEstateId(self, estateId): self.estateId = estateId def setTargetId(self, targetId): self.notify.debug('setTargetId %d' % targetId) self.targetId = targetId def setPosHpr(self, x, y, z, h, p, r): self.nodePath.setPosHpr(x, y, z, h, p, r) def setMovie(self, mode, avId): wasLocalToon = self.localToonShooting self.avId = avId if mode == CannonGlobals.CANNON_MOVIE_CLEAR: self.listenForCode() self.setLanded() elif mode == CannonGlobals.CANNON_MOVIE_LANDED: self.setLanded() elif mode == CannonGlobals.CANNON_MOVIE_FORCE_EXIT: self.exitCannon(self.avId) self.setLanded() elif mode == CannonGlobals.CANNON_MOVIE_LOAD: self.ignoreCode() if self.avId == base.localAvatar.doId: base.localAvatar.pose('lose', 110) base.localAvatar.pose('slip-forward', 25) base.cr.playGame.getPlace().setState('fishing') base.localAvatar.setTeleportAvailable(0) base.localAvatar.collisionsOff() base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 0) base.setCellsAvailable([base.rightCells[1]], 0) self.localToonShooting = 1 self.__makeGui() camera.reparentTo(self.barrel) camera.setPos(0.5, -2, 2.5) self.curPinballScore = 0 self.curPinballMultiplier = 1 self.incrementPinballInfo(0, 0) if self.cr.doId2do.has_key(self.avId): self.av = self.cr.doId2do[self.avId] self.acceptOnce(self.av.uniqueName('disable'), self.__avatarGone) self.av.stopSmooth() self.__createToonModels() else: self.notify.warning('Unknown avatar %d in cannon %d' % (self.avId, self.doId)) if wasLocalToon and not self.localToonShooting: base.setCellsAvailable([base.bottomCells[3], base.bottomCells[4]], 1) base.setCellsAvailable([base.rightCells[1]], 1) def __avatarGone(self): self.setMovie(CannonGlobals.CANNON_MOVIE_CLEAR, 0) def load(self): self.cannon = loader.loadModel('phase_4/models/minigames/toon_cannon') self.shadow = loader.loadModel('phase_3/models/props/drop_shadow') self.shadowNode = hidden.attachNewNode('dropShadow') self.shadow.copyTo(self.shadowNode) self.smoke = loader.loadModel('phase_4/models/props/test_clouds') self.smoke.setBillboardPointEye() self.cannon.setScale(CANNON_SCALE) self.shadowNode.setColor(0, 0, 0, 0.5) self.shadowNode.setBin('fixed', 0, 1) self.splash = Splash.Splash(render) self.dustCloud = DustCloud.DustCloud(render) self.dustCloud.setBillboardPointEye() self.sndCannonMove = base.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.ogg') self.sndCannonFire = base.loadSfx('phase_4/audio/sfx/MG_cannon_fire_alt.ogg') self.sndHitGround = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_dirt.ogg') self.sndHitTower = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_tower.ogg') self.sndHitWater = base.loadSfx('phase_4/audio/sfx/MG_cannon_splash.ogg') self.sndWhizz = base.loadSfx('phase_4/audio/sfx/MG_cannon_whizz.ogg') self.sndWin = base.loadSfx('phase_4/audio/sfx/MG_win.ogg') self.sndHitHouse = base.loadSfx('phase_5/audio/sfx/AA_drop_sandbag.ogg') self.collSphere = CollisionSphere(0, 0, 0, self.getSphereRadius()) self.collSphere.setTangible(1) self.collNode = CollisionNode(self.uniqueName('CannonSphere')) self.collNode.setCollideMask(ToontownGlobals.WallBitmask) self.collNode.addSolid(self.collSphere) self.collNodePath = self.nodePath.attachNewNode(self.collNode) self.loadCannonBumper() def setupMovingShadow(self): self.cTrav = base.cTrav self.cRay = CollisionRay(0.0, 0.0, CollisionHandlerRayStart, 0.0, 0.0, -1.0) self.cRayNode = CollisionNode('cRayNode') self.cRayNode.addSolid(self.cRay) self.cRayNodePath = self.shadowNode.attachNewNode(self.cRayNode) self.cRayNodePath.hide() self.cRayBitMask = ToontownGlobals.FloorBitmask self.cRayNode.setFromCollideMask(self.cRayBitMask) self.cRayNode.setIntoCollideMask(BitMask32.allOff()) self.lifter = CollisionHandlerFloor() self.lifter.setOffset(ToontownGlobals.FloorOffset) self.lifter.setReach(20.0) self.enableRaycast(1) def enableRaycast(self, enable = 1): if not self.cTrav or not hasattr(self, 'cRayNode') or not self.cRayNode: return self.notify.debug('-------enabling raycast--------') self.cTrav.removeCollider(self.cRayNodePath) if enable: self.cTrav.addCollider(self.cRayNodePath, self.lifter) def __makeGui(self): if self.madeGui: return guiModel = 'phase_4/models/gui/cannon_game_gui' cannonGui = loader.loadModel(guiModel) self.aimPad = DirectFrame(image=cannonGui.find('**/CannonFire_PAD'), relief=None, pos=(0.7, 0, -0.553333), scale=0.8) cannonGui.removeNode() self.fireButton = DirectButton(parent=self.aimPad, image=((guiModel, '**/Fire_Btn_UP'), (guiModel, '**/Fire_Btn_DN'), (guiModel, '**/Fire_Btn_RLVR')), relief=None, pos=(0.0115741, 0, 0.00505051), scale=1.0, command=self.__firePressed) self.upButton = DirectButton(parent=self.aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.0115741, 0, 0.221717)) self.downButton = DirectButton(parent=self.aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.0136112, 0, -0.210101), image_hpr=(0, 0, 180)) self.leftButton = DirectButton(parent=self.aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(-0.199352, 0, -0.000505269), image_hpr=(0, 0, -90)) self.rightButton = DirectButton(parent=self.aimPad, image=((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief=None, pos=(0.219167, 0, -0.00101024), image_hpr=(0, 0, 90)) self.aimPad.setColor(1, 1, 1, 0.9) def bindButton(button, upHandler, downHandler): button.bind(DGG.B1PRESS, lambda x, handler = upHandler: handler()) button.bind(DGG.B1RELEASE, lambda x, handler = downHandler: handler()) bindButton(self.upButton, self.__upPressed, self.__upReleased) bindButton(self.downButton, self.__downPressed, self.__downReleased) bindButton(self.leftButton, self.__leftPressed, self.__leftReleased) bindButton(self.rightButton, self.__rightPressed, self.__rightReleased) self.__enableAimInterface() self.madeGui = 1 return def __unmakeGui(self): self.notify.debug('__unmakeGui') if not self.madeGui: return self.__disableAimInterface() self.upButton.unbind(DGG.B1PRESS) self.upButton.unbind(DGG.B1RELEASE) self.downButton.unbind(DGG.B1PRESS) self.downButton.unbind(DGG.B1RELEASE) self.leftButton.unbind(DGG.B1PRESS) self.leftButton.unbind(DGG.B1RELEASE) self.rightButton.unbind(DGG.B1PRESS) self.rightButton.unbind(DGG.B1RELEASE) self.aimPad.destroy() del self.aimPad del self.fireButton del self.upButton del self.downButton del self.leftButton del self.rightButton self.madeGui = 0 def unload(self): self.ignoreCode() del self.codeFSM if self.cannon: self.cannon.removeNode() self.cannon = None if self.shadowNode != None: self.shadowNode.removeNode() del self.shadowNode if self.splash != None: self.splash.destroy() del self.splash if self.dustCloud != None: self.dustCloud.destroy() del self.dustCloud del self.sndCannonMove del self.sndCannonFire del self.sndHitHouse del self.sndHitGround del self.sndHitTower del self.sndHitWater del self.sndWhizz del self.sndWin self.bumperCol = None taskMgr.remove(self.uniqueName('BumperON')) if self.av: self.__resetToon(self.av) self.av.loop('neutral') self.av.setPlayRate(1.0, 'run') if hasattr(self.av, 'nametag'): self.av.nametag.removeNametag(self.toonHead.tag) if self.toonHead != None: self.toonHead.stopBlink() self.toonHead.stopLookAroundNow() self.toonHead.delete() self.toonHead = None if self.toonModel != None: self.toonModel.removeNode() self.toonModel = None del self.toonScale del self.cannonLocation del self.cRay del self.cRayNode if self.cRayNodePath: self.cRayNodePath.removeNode() del self.cRayNodePath del self.lifter self.enableRaycast(0) return def onstage(self): self.__createCannon() self.cannon.reparentTo(self.nodePath) self.splash.reparentTo(render) self.dustCloud.reparentTo(render) def offstage(self): if self.cannon: self.cannon.reparentTo(hidden) if self.splash: self.splash.reparentTo(hidden) self.splash.stop() if self.dustCloud: self.dustCloud.reparentTo(hidden) self.dustCloud.stop() def __createCannon(self): self.barrel = self.cannon.find('**/cannon') self.cannonLocation = Point3(0, 0, 0.025) self.cannonPosition = [0, CANNON_ANGLE_MIN] self.cannon.setPos(self.cannonLocation) self.__updateCannonPosition(self.avId) def __createToonModels(self): self.model_Created = 1 toon = self.av self.toonScale = toon.getScale() toon.useLOD(1000) toonParent = render.attachNewNode('toonOriginChange') toon.wrtReparentTo(toonParent) toon.setPosHpr(0, 0, -(toon.getHeight() / 2.0), 0, -90, 0) self.toonModel = toonParent self.toonHead = ToonHead.ToonHead() self.toonHead.setupHead(self.av.style) self.toonHead.reparentTo(hidden) tag = NametagFloat3d() tag.setContents(Nametag.CSpeech | Nametag.CThought) tag.setBillboardOffset(0) tag.setAvatar(self.toonHead) toon.nametag.addNametag(tag) tagPath = self.toonHead.attachNewNode(tag) tagPath.setPos(0, 0, 1) self.toonHead.tag = tag self.__loadToonInCannon() self.av.dropShadow.hide() self.dropShadow = self.shadowNode.copyTo(hidden) def __destroyToonModels(self): if self.av != None: self.av.dropShadow.show() if self.dropShadow != None: self.dropShadow.removeNode() self.dropShadow = None self.hitBumper = 0 self.hitTarget = 0 self.angularVel = 0 self.vel = Vec3(0, 0, 0) self.lastVel = Vec3(0, 0, 0) self.lastPos = Vec3(0, 0, 0) self.landingPos = Vec3(0, 0, 0) self.t = 0 self.lastT = 0 self.deltaT = 0 self.av = None self.lastWakeTime = 0 self.localToonShooting = 0 if self.toonHead != None: self.toonHead.reparentTo(hidden) self.toonHead.stopBlink() self.toonHead.stopLookAroundNow() self.toonHead.delete() self.toonHead = None if self.toonModel != None: self.toonModel.removeNode() self.toonModel = None self.model_Created = 0 return def updateCannonPosition(self, avId, zRot, angle): if avId != self.localAvId: self.cannonPosition = [zRot, angle] self.__updateCannonPosition(avId) def setCannonWillFire(self, avId, fireTime, zRot, angle, timestamp): self.notify.debug('setCannonWillFire: ' + str(avId) + ': zRot=' + str(zRot) + ', angle=' + str(angle) + ', time=' + str(fireTime)) if not self.model_Created: self.notify.warning("We walked into the zone mid-flight, so we won't see it") return self.cannonPosition[0] = zRot self.cannonPosition[1] = angle self.__updateCannonPosition(avId) task = Task(self.__fireCannonTask) task.avId = avId ts = globalClockDelta.localElapsedTime(timestamp) task.fireTime = fireTime - ts if task.fireTime < 0.0: task.fireTime = 0.0 taskMgr.add(task, self.taskNameFireCannon) def exitCannon(self, avId): self.__unmakeGui() if self.avId == avId: if self.av: self.__resetToonToCannon(self.av) def __enableAimInterface(self): self.aimPad.show() self.accept(self.FIRE_KEY, self.__fireKeyPressed) self.accept(self.UP_KEY, self.__upKeyPressed) self.accept(self.DOWN_KEY, self.__downKeyPressed) self.accept(self.LEFT_KEY, self.__leftKeyPressed) self.accept(self.RIGHT_KEY, self.__rightKeyPressed) self.accept(self.BUMPER_KEY, self.__bumperKeyPressed) self.accept(self.BUMPER_KEY2, self.__bumperKeyPressed) self.__spawnLocalCannonMoveTask() def __disableAimInterface(self): self.aimPad.hide() self.ignore(self.FIRE_KEY) self.ignore(self.UP_KEY) self.ignore(self.DOWN_KEY) self.ignore(self.LEFT_KEY) self.ignore(self.RIGHT_KEY) self.ignore(self.FIRE_KEY + '-up') self.ignore(self.UP_KEY + '-up') self.ignore(self.DOWN_KEY + '-up') self.ignore(self.LEFT_KEY + '-up') self.ignore(self.RIGHT_KEY + '-up') self.__killLocalCannonMoveTask() def __fireKeyPressed(self): self.ignore(self.FIRE_KEY) self.accept(self.FIRE_KEY + '-up', self.__fireKeyReleased) self.__firePressed() def __upKeyPressed(self): self.ignore(self.UP_KEY) self.accept(self.UP_KEY + '-up', self.__upKeyReleased) self.__upPressed() def __downKeyPressed(self): self.ignore(self.DOWN_KEY) self.accept(self.DOWN_KEY + '-up', self.__downKeyReleased) self.__downPressed() def __leftKeyPressed(self): self.ignore(self.LEFT_KEY) self.accept(self.LEFT_KEY + '-up', self.__leftKeyReleased) self.__leftPressed() def __rightKeyPressed(self): self.ignore(self.RIGHT_KEY) self.accept(self.RIGHT_KEY + '-up', self.__rightKeyReleased) self.__rightPressed() def __fireKeyReleased(self): self.ignore(self.FIRE_KEY + '-up') self.accept(self.FIRE_KEY, self.__fireKeyPressed) self.__fireReleased() def __leftKeyReleased(self): self.ignore(self.LEFT_KEY + '-up') self.accept(self.LEFT_KEY, self.__leftKeyPressed) self.handleCodeKey('left') self.__leftReleased() def __rightKeyReleased(self): self.ignore(self.RIGHT_KEY + '-up') self.accept(self.RIGHT_KEY, self.__rightKeyPressed) self.handleCodeKey('right') self.__rightReleased() def __upKeyReleased(self): self.ignore(self.UP_KEY + '-up') self.accept(self.UP_KEY, self.__upKeyPressed) self.__upReleased() def __downKeyReleased(self): self.ignore(self.DOWN_KEY + '-up') self.accept(self.DOWN_KEY, self.__downKeyPressed) self.handleCodeKey('down') self.__downReleased() def __upKeyCode(self): self.handleCodeKey('up') def __downKeyCode(self): self.handleCodeKey('down') def __rightKeyCode(self): self.handleCodeKey('right') def __leftKeyCode(self): self.handleCodeKey('left') def __firePressed(self): self.notify.debug('fire pressed') self.__broadcastLocalCannonPosition() self.__unmakeGui() self.sendUpdate('setCannonLit', [self.cannonPosition[0], self.cannonPosition[1]]) def __upPressed(self): self.notify.debug('up pressed') self.upPressed = self.__enterControlActive(self.upPressed) def __downPressed(self): self.notify.debug('down pressed') self.downPressed = self.__enterControlActive(self.downPressed) def __leftPressed(self): self.notify.debug('left pressed') self.leftPressed = self.__enterControlActive(self.leftPressed) def __rightPressed(self): self.notify.debug('right pressed') self.rightPressed = self.__enterControlActive(self.rightPressed) def __upReleased(self): self.notify.debug('up released') self.upPressed = self.__exitControlActive(self.upPressed) def __downReleased(self): self.notify.debug('down released') self.downPressed = self.__exitControlActive(self.downPressed) def __leftReleased(self): self.notify.debug('left released') self.leftPressed = self.__exitControlActive(self.leftPressed) def __rightReleased(self): self.notify.debug('right released') self.rightPressed = self.__exitControlActive(self.rightPressed) def __enterControlActive(self, control): return control + 1 def __exitControlActive(self, control): return max(0, control - 1) def __spawnLocalCannonMoveTask(self): self.leftPressed = 0 self.rightPressed = 0 self.upPressed = 0 self.downPressed = 0 self.cannonMoving = 0 task = Task(self.__localCannonMoveTask) task.lastPositionBroadcastTime = 0.0 taskMgr.add(task, self.LOCAL_CANNON_MOVE_TASK) def __killLocalCannonMoveTask(self): taskMgr.remove(self.LOCAL_CANNON_MOVE_TASK) if self.cannonMoving: self.sndCannonMove.stop() def __localCannonMoveTask(self, task): pos = self.cannonPosition oldRot = pos[0] oldAng = pos[1] rotVel = 0 if self.leftPressed: rotVel += CANNON_ROTATION_VEL if self.rightPressed: rotVel -= CANNON_ROTATION_VEL pos[0] += rotVel * globalClock.getDt() if pos[0] < CANNON_ROTATION_MIN: pos[0] = CANNON_ROTATION_MIN elif pos[0] > CANNON_ROTATION_MAX: pos[0] = CANNON_ROTATION_MAX angVel = 0 if self.upPressed: angVel += CANNON_ANGLE_VEL if self.downPressed: angVel -= CANNON_ANGLE_VEL pos[1] += angVel * globalClock.getDt() if pos[1] < CANNON_ANGLE_MIN: pos[1] = CANNON_ANGLE_MIN elif pos[1] > CANNON_ANGLE_MAX: pos[1] = CANNON_ANGLE_MAX if oldRot != pos[0] or oldAng != pos[1]: if self.cannonMoving == 0: self.cannonMoving = 1 base.playSfx(self.sndCannonMove, looping=1) self.__updateCannonPosition(self.localAvId) if task.time - task.lastPositionBroadcastTime > CANNON_MOVE_UPDATE_FREQ: task.lastPositionBroadcastTime = task.time self.__broadcastLocalCannonPosition() elif self.cannonMoving: self.cannonMoving = 0 self.sndCannonMove.stop() self.__broadcastLocalCannonPosition() print 'Cannon Rot:%s Angle:%s' % (pos[0], pos[1]) return Task.cont def __broadcastLocalCannonPosition(self): self.sendUpdate('setCannonPosition', [self.cannonPosition[0], self.cannonPosition[1]]) def __updateCannonPosition(self, avId): self.cannon.setHpr(self.cannonPosition[0], 0.0, 0.0) self.barrel.setHpr(0.0, self.cannonPosition[1], 0.0) maxP = 90 newP = self.barrel.getP() yScale = 1 - 0.5 * float(newP) / maxP shadow = self.cannon.find('**/square_drop_shadow') shadow.setScale(1, yScale, 1) def __getCameraPositionBehindCannon(self): return Point3(self.cannonLocationDict[self.localAvId][0], CANNON_Y - 5.0, CANNON_Z + 7) def __putCameraBehindCannon(self): camera.setPos(self.__getCameraPositionBehindCannon()) camera.setHpr(0, 0, 0) def __loadToonInCannon(self): self.toonModel.reparentTo(hidden) self.toonHead.startBlink() self.toonHead.startLookAround() self.toonHead.reparentTo(self.barrel) self.toonHead.setPosHpr(0, 6, 0, 0, -45, 0) sc = self.toonScale self.toonHead.setScale(render, sc[0], sc[1], sc[2]) self.toonModel.setPos(self.toonHead.getPos(render)) def __toRadians(self, angle): return angle * 2.0 * math.pi / 360.0 def __toDegrees(self, angle): return angle * 360.0 / (2.0 * math.pi) def __calcFlightResults(self, avId, launchTime): head = self.toonHead startPos = head.getPos(render) startHpr = head.getHpr(render) hpr = self.barrel.getHpr(render) rotation = self.__toRadians(hpr[0]) angle = self.__toRadians(hpr[1]) horizVel = INITIAL_VELOCITY * math.cos(angle) xVel = horizVel * -math.sin(rotation) yVel = horizVel * math.cos(rotation) zVel = INITIAL_VELOCITY * math.sin(angle) startVel = Vec3(xVel, yVel, zVel) trajectory = Trajectory.Trajectory(launchTime, startPos, startVel) self.trajectory = trajectory hitTreasures = self.__calcHitTreasures(trajectory) timeOfImpact, hitWhat = self.__calcToonImpact(trajectory) return startPos, startHpr, startVel, trajectory, 3 * timeOfImpact, hitWhat def __fireCannonTask(self, task): launchTime = task.fireTime avId = task.avId self.inWater = 0 if not self.toonHead: return Task.done startPos, startHpr, startVel, trajectory, timeOfImpact, hitWhat = self.__calcFlightResults(avId, launchTime) self.notify.debug('start position: ' + str(startPos)) self.notify.debug('start velocity: ' + str(startVel)) self.notify.debug('time of launch: ' + str(launchTime)) self.notify.debug('time of impact: ' + str(timeOfImpact)) self.notify.debug('location of impact: ' + str(trajectory.getPos(timeOfImpact))) if hitWhat == self.HIT_WATER: self.notify.debug('toon will land in the water') elif hitWhat == self.HIT_TOWER: self.notify.debug('toon will hit the tower') else: self.notify.debug('toon will hit the ground') head = self.toonHead head.stopBlink() head.stopLookAroundNow() head.reparentTo(hidden) av = self.toonModel av.reparentTo(render) print 'start Pos%s Hpr%s' % (startPos, startHpr) av.setPos(startPos) barrelHpr = self.barrel.getHpr(render) place = base.cr.playGame.getPlace() if self.av == base.localAvatar: place.fsm.request('stopped') av.setHpr(startHpr) avatar = self.av avatar.loop('swim') avatar.setPosHpr(0, 0, -(avatar.getHeight() / 2.0), 0, 0, 0) info = {} info['avId'] = avId info['trajectory'] = trajectory info['launchTime'] = launchTime info['timeOfImpact'] = timeOfImpact info['hitWhat'] = hitWhat info['toon'] = self.toonModel info['hRot'] = self.cannonPosition[0] info['haveWhistled'] = 0 info['maxCamPullback'] = CAMERA_PULLBACK_MIN if self.localToonShooting: camera.reparentTo(self.av) camera.setP(45.0) camera.setZ(-10.0) self.flyColSphere = CollisionSphere(0, 0, self.av.getHeight() / 2.0, 1.0) self.flyColNode = CollisionNode(self.uniqueName('flySphere')) self.flyColNode.setCollideMask(ToontownGlobals.WallBitmask | ToontownGlobals.FloorBitmask) self.flyColNode.addSolid(self.flyColSphere) self.flyColNodePath = self.av.attachNewNode(self.flyColNode) self.flyColNodePath.setColor(1, 0, 0, 1) self.handler = CollisionHandlerEvent() self.handler.setInPattern(self.uniqueName('cannonHit')) base.cTrav.addCollider(self.flyColNodePath, self.handler) self.accept(self.uniqueName('cannonHit'), self.__handleCannonHit) shootTask = Task(self.__shootTask, self.taskNameShoot) smokeTask = Task(self.__smokeTask, self.taskNameSmoke) flyTask = Task(self.__flyTask, self.taskNameFly) shootTask.info = info flyTask.info = info seqTask = Task.sequence(shootTask, smokeTask, flyTask) if self.av == base.localAvatar: print 'disable controls' base.localAvatar.disableAvatarControls() taskMgr.add(seqTask, self.taskName('flyingToon') + '-' + str(avId)) self.acceptOnce(self.uniqueName('stopFlyTask'), self.__stopFlyTask) return Task.done def __stopFlyTask(self, avId): taskMgr.remove(self.taskName('flyingToon') + '-' + str(avId)) def b_setLanded(self): self.d_setLanded() def d_setLanded(self): self.notify.debug('localTOonshooting = %s' % self.localToonShooting) if self.localToonShooting: self.sendUpdate('setLanded', []) def setLanded(self): self.removeAvFromCannon() def removeAvFromCannon(self): place = base.cr.playGame.getPlace() print 'removeAvFromCannon' self.notify.debug('self.inWater = %s' % self.inWater) if place: if not hasattr(place, 'fsm'): return placeState = place.fsm.getCurrentState().getName() print placeState if (self.inWater or place.toonSubmerged) and placeState != 'fishing': if self.av != None: self.av.startSmooth() self.__destroyToonModels() return self.inWater = 0 if self.av != None: self.__stopCollisionHandler(self.av) self.av.resetLOD() if self.av == base.localAvatar: if place and not self.inWater: place.fsm.request('walk') self.av.setPlayRate(1.0, 'run') self.av.nametag.removeNametag(self.toonHead.tag) if self.av.getParent().getName() == 'toonOriginChange': self.av.wrtReparentTo(render) self.__setToonUpright(self.av) if self.av == base.localAvatar: self.av.startPosHprBroadcast() self.av.startSmooth() self.av.setScale(1, 1, 1) if self.av == base.localAvatar: print 'enable controls' base.localAvatar.enableAvatarControls() self.ignore(self.av.uniqueName('disable')) self.__destroyToonModels() return def __stopCollisionHandler(self, avatar): if avatar: avatar.loop('neutral') if self.flyColNode: self.flyColNode = None if avatar == base.localAvatar: avatar.collisionsOn() self.flyColSphere = None if self.flyColNodePath: base.cTrav.removeCollider(self.flyColNodePath) self.flyColNodePath.removeNode() self.flyColNodePath = None self.handler = None return def __handleCannonHit(self, collisionEntry): if self.av == None or self.flyColNode == None: return hitNode = collisionEntry.getIntoNode().getName() self.notify.debug('hitNode = %s' % hitNode) self.notify.debug('hitNodePath.getParent = %s' % collisionEntry.getIntoNodePath().getParent()) self.vel = self.trajectory.getVel(self.t) vel = self.trajectory.getVel(self.t) vel.normalize() if self.hitBumper: vel = self.lastVel * 1 vel.normalize() self.notify.debug('normalized vel=%s' % vel) solid = collisionEntry.getInto() intoNormal = collisionEntry.getSurfaceNormal(collisionEntry.getIntoNodePath()) self.notify.debug('old intoNormal = %s' % intoNormal) intoNormal = collisionEntry.getSurfaceNormal(render) self.notify.debug('new intoNormal = %s' % intoNormal) hitPylonAboveWater = False hitPylonBelowWater = False if hitNode in ['pier_pylon_collisions_1', 'pier_pylon_collisions_3']: if collisionEntry.getSurfacePoint(render)[2] > 0: hitPylonAboveWater = True self.notify.debug('hitPylonAboveWater = True') else: hitPylonBelowWater = True self.notify.debug('hitPylonBelowWater = True') hitNormal = intoNormal if ( hitNode.find('cSphere') == 0 or hitNode.find('treasureSphere') == 0 or hitNode.find('prop') == 0 or hitNode.find('distAvatarCollNode') == 0 or hitNode.find('CannonSphere') == 0 or hitNode.find('plotSphere') == 0 or hitNode.find('flySphere') == 0 or hitNode.find('mailboxSphere') == 0 or hitNode.find('FishingSpotSphere') == 0 or hitNode == 'gagtree_collision' or hitNode == 'sign_collision' or hitNode == 'FlowerSellBox' or hitPylonBelowWater): self.notify.debug('--------------hit and ignoring %s' % hitNode) return if vel.dot(hitNormal) > 0 and not hitNode == 'collision_roof' and not hitNode == 'collision_fence': self.notify.debug('--------------hit and ignoring backfacing %s, dot=%s' % (hitNode, vel.dot(hitNormal))) return intoNode = collisionEntry.getIntoNodePath() bumperNodes = ['collision_house', 'collision_fence', 'targetSphere', 'collision_roof', 'collision_cannon_bumper', 'statuaryCol'] cloudBumpers = ['cloudSphere-0'] bumperNodes += cloudBumpers if hitNode not in bumperNodes: self.__stopCollisionHandler(self.av) self.__stopFlyTask(self.avId) self.notify.debug('stopping flying since we hit %s' % hitNode) if self.hitTarget == 0: messenger.send('missedTarget') else: if hitNode == 'collision_house': self.__hitHouse(self.av, collisionEntry) elif hitNode == 'collision_fence': self.__hitFence(self.av, collisionEntry) elif hitNode == 'collision_roof': self.__hitRoof(self.av, collisionEntry) elif hitNode == 'targetSphere': self.__hitTarget(self.av, collisionEntry, [vel]) elif hitNode in cloudBumpers: self.__hitCloudPlatform(self.av, collisionEntry) elif hitNode == 'collision_cannon_bumper': self.__hitCannonBumper(self.av, collisionEntry) elif hitNode == 'statuaryCol': self.__hitStatuary(self.av, collisionEntry) else: self.notify.debug('*************** hit something else ************') return if self.localToonShooting: camera.wrtReparentTo(render) if self.dropShadow: self.dropShadow.reparentTo(hidden) pos = collisionEntry.getSurfacePoint(render) hpr = self.av.getHpr() hitPos = collisionEntry.getSurfacePoint(render) pos = hitPos self.landingPos = pos self.notify.debug('hitNode,Normal = %s,%s' % (hitNode, intoNormal)) track = Sequence() track.append(Func(self.av.wrtReparentTo, render)) if self.localToonShooting: track.append(Func(self.av.collisionsOff)) if hitPylonAboveWater or hitNode in ['matCollisions', 'collision1', 'floor', 'sand_collision', 'dirt_collision', 'soil1', 'collision2', 'floor_collision']: track.append(Func(self.__hitGround, self.av, pos)) track.append(Wait(1.0)) track.append(Func(self.__setToonUpright, self.av, self.landingPos)) elif hitNode == 'collision_house': track.append(Func(self.__hitHouse, self.av, collisionEntry)) elif hitNode == 'collision_fence' or hitNode == 'collision4': track.append(Func(self.__hitFence, self.av, collisionEntry)) elif hitNode == 'targetSphere': track.append(Func(self.__hitHouse, self.av, collisionEntry)) elif hitNode == 'collision3': track.append(Func(self.__hitWater, self.av, pos, collisionEntry)) track.append(Wait(2.0)) track.append(Func(self.__setToonUpright, self.av, self.landingPos)) elif hitNode == 'roofOutside' or hitNode == 'collision_roof' or hitNode == 'roofclision': track.append(Func(self.__hitRoof, self.av, collisionEntry)) track.append(Wait(2.0)) track.append(Func(self.__setToonUpright, self.av, self.landingPos)) elif hitNode.find('MovingPlatform') == 0 or hitNode.find('cloudSphere') == 0: track.append(Func(self.__hitCloudPlatform, self.av, collisionEntry)) else: self.notify.warning('************* unhandled hitNode=%s parent =%s' % (hitNode, collisionEntry.getIntoNodePath().getParent())) track.append(Func(self.b_setLanded)) if self.localToonShooting: track.append(Func(self.av.collisionsOn)) if 1: if self.hitTrack: self.hitTrack.finish() self.hitTrack = track self.hitTrack.start() def __hitGround(self, avatar, pos, extraArgs = []): hitP = avatar.getPos(render) self.notify.debug('hitGround pos = %s, hitP = %s' % (pos, hitP)) self.notify.debug('avatar hpr = %s' % avatar.getHpr()) h = self.barrel.getH(render) avatar.setPos(pos[0], pos[1], pos[2] + avatar.getHeight() / 3.0) avatar.setHpr(h, -135, 0) self.notify.debug('parent = %s' % avatar.getParent()) self.notify.debug('pos = %s, hpr = %s' % (avatar.getPos(render), avatar.getHpr(render))) self.dustCloud.setPos(render, pos[0], pos[1], pos[2] + avatar.getHeight() / 3.0) self.dustCloud.setScale(0.35) self.dustCloud.play() base.playSfx(self.sndHitGround) avatar.setPlayRate(2.0, 'run') avatar.loop('run') def __hitHouse(self, avatar, collisionEntry, extraArgs = []): self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.2, angVel=3) pinballScore = ToontownGlobals.PinballScoring[ToontownGlobals.PinballHouse] self.incrementPinballInfo(pinballScore[0], pinballScore[1]) def __hitFence(self, avatar, collisionEntry, extraArgs = []): self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.2, angVel=3) pinballScore = ToontownGlobals.PinballScoring[ToontownGlobals.PinballFence] self.incrementPinballInfo(pinballScore[0], pinballScore[1]) def __hitTarget(self, avatar, collisionEntry, extraArgs = []): self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.1, angVel=2) pinballScore = ToontownGlobals.PinballScoring[ToontownGlobals.PinballTarget] self.incrementPinballInfo(pinballScore[0], pinballScore[1]) if self.localToonShooting: self.hitTarget = 1 messenger.send('hitTarget', [self.avId, self.lastVel]) def __hitBumper(self, avatar, collisionEntry, sound, kr = 0.6, angVel = 1): self.hitBumper = 1 base.playSfx(self.sndHitHouse) hitP = avatar.getPos(render) self.lastPos = hitP house = collisionEntry.getIntoNodePath() normal = collisionEntry.getSurfaceNormal(house) normal.normalize() normal = collisionEntry.getSurfaceNormal(render) self.notify.debug('normal = %s' % normal) vel = self.vel * 1 speed = vel.length() vel.normalize() self.notify.debug('old vel = %s' % vel) newVel = (normal * 2.0 + vel) * (kr * speed) self.lastVel = newVel self.notify.debug('new vel = %s' % newVel) self.angularVel = angVel * 360 t = Sequence(Func(avatar.pose, 'lose', 110)) t.start() def __hitRoof(self, avatar, collisionEntry, extraArgs = []): if True: self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.3, angVel=3) pinballScore = ToontownGlobals.PinballScoring[ToontownGlobals.PinballRoof] self.incrementPinballInfo(pinballScore[0], pinballScore[1]) return np = collisionEntry.getIntoNodePath() roof = np.getParent() normal = collisionEntry.getSurfaceNormal(np) normal.normalize() vel = self.trajectory.getVel(self.t) vel.normalize() dot = normal.dot(vel) self.notify.debug('--------------dot product = %s---------------' % dot) temp = render.attachNewNode('temp') temp.iPosHpr() temp.lookAt(Point3(normal)) temp.reparentTo(roof) self.notify.debug('avatar pos = %s, landingPos = %s' % (avatar.getPos(), self.landingPos)) temp.setPos(render, self.landingPos) avatar.reparentTo(temp) avatar.setPosHpr(0, 0.25, 0.5, 0, 270, 180) avatar.pose('slip-forward', 25) base.playSfx(self.sndHitHouse) avatar.setPlayRate(1.0, 'jump') h = self.barrel.getH(render) t = Sequence(LerpPosInterval(avatar, 0.5, Point3(0, 0, -.5), blendType='easeInOut'), Func(avatar.clearColorScale), Func(avatar.wrtReparentTo, render), Wait(0.3), Parallel(Func(avatar.setP, 0), Func(avatar.play, 'jump', None, 19, 39), LerpHprInterval(avatar, 0.3, Vec3(h, 0, 0), blendType='easeOut')), Func(avatar.play, 'neutral')) t.start() hitP = avatar.getPos(render) return def __hitBridge(self, avatar, collisionEntry, extraArgs = []): self.notify.debug('hit bridge') hitP = avatar.getPos(render) self.dustCloud.setPos(render, hitP[0], hitP[1], hitP[2] - 0.5) self.dustCloud.setScale(0.35) self.dustCloud.play() base.playSfx(self.sndHitGround) def __hitWater(self, avatar, pos, collisionEntry, extraArgs = []): hitP = avatar.getPos(render) if hitP[2] > ToontownGlobals.EstateWakeWaterHeight: self.notify.debug('we hit the ground before we hit water') self.__hitGround(avatar, pos, extraArgs) print 'but not really' return self.inWater = 1 self.notify.debug('hit water') hitP = avatar.getPos(render) avatar.loop('neutral') self.splash.setPos(hitP) self.splash.setZ(ToontownGlobals.EstateWakeWaterHeight) self.splash.setScale(2) self.splash.play() base.playSfx(self.sndHitWater) place = base.cr.playGame.getPlace() self.notify.debug('hitWater: submerged = %s' % place.toonSubmerged) def __hitCannonBumper(self, avatar, collisionEntry, extraArgs = []): self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.4, angVel=5) score, multiplier = ToontownGlobals.PinballScoring[ToontownGlobals.PinballCannonBumper] self.incrementPinballInfo(score, multiplier) def __hitStatuary(self, avatar, collisionEntry, extraArgs = []): self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.4, angVel=5) score, multiplier = ToontownGlobals.PinballScoring[ToontownGlobals.PinballStatuary] intoNodePath = collisionEntry.getIntoNodePath() name = intoNodePath.getParent().getName() splitParts = name.split('-') if len(splitParts) >= 3: score = int(splitParts[1]) multiplier = int(splitParts[2]) self.incrementPinballInfo(score, multiplier) def __hitCloudPlatform(self, avatar, collisionEntry, extraArgs = []): if True: self.__hitBumper(avatar, collisionEntry, self.sndHitHouse, kr=0.4, angVel=5) score, multiplier = ToontownGlobals.PinballScoring[ToontownGlobals.PinballCloudBumperLow] intoNodePath = collisionEntry.getIntoNodePath() name = intoNodePath.getParent().getName() splitParts = name.split('-') if len(splitParts) >= 3: score = int(splitParts[1]) multiplier = int(splitParts[2]) self.incrementPinballInfo(score, multiplier) return avatar.reparentTo(collisionEntry.getIntoNodePath()) h = self.barrel.getH(render) avatar.setPosHpr(0, 0, 0, h, 0, 0) messenger.send('hitCloud') def __setToonUpright(self, avatar, pos = None): if avatar: if self.inWater: avatar.setP(0) avatar.setR(0) return if not pos: pos = avatar.getPos(render) avatar.setPos(render, pos) avatar.loop('neutral') place = base.cr.playGame.getPlace() h = self.barrel.getH(render) p = Point3(self.vel[0], self.vel[1], self.vel[2]) self.notify.debug('lookat = %s' % p) if hasattr(self, 'cannon') and self.cannon: avatar.lookAt(self.cannon) avatar.setP(0) avatar.setR(0) avatar.setScale(1, 1, 1) def __calcToonImpact(self, trajectory): t_groundImpact = trajectory.checkCollisionWithGround(GROUND_PLANE_MIN) if t_groundImpact >= trajectory.getStartTime(): return (t_groundImpact, self.HIT_GROUND) else: self.notify.error('__calcToonImpact: toon never impacts ground?') return (0.0, self.HIT_GROUND) def __calcHitTreasures(self, trajectory): estate = self.cr.doId2do.get(self.estateId) self.hitTreasures = [] if estate: doIds = estate.flyingTreasureId for id in doIds: t = self.cr.doId2do.get(id) if t: pos = t.nodePath.getPos() rad = 10.5 height = 10.0 t_impact = trajectory.checkCollisionWithCylinderSides(pos, rad, height) if t_impact > 0: self.hitTreasures.append([t_impact, t]) del estate return None def __shootTask(self, task): base.playSfx(self.sndCannonFire) self.dropShadow.reparentTo(render) return Task.done def __smokeTask(self, task): self.smoke.reparentTo(self.barrel) self.smoke.setPos(0, 6, -3) self.smoke.setScale(0.5) self.smoke.wrtReparentTo(render) track = Sequence(Parallel(LerpScaleInterval(self.smoke, 0.5, 3), LerpColorScaleInterval(self.smoke, 0.5, Vec4(2, 2, 2, 0))), Func(self.smoke.reparentTo, hidden), Func(self.smoke.clearColorScale)) track.start() return Task.done def __flyTask(self, task): toon = task.info['toon'] if toon.isEmpty(): self.__resetToonToCannon(self.av) return Task.done curTime = task.time + task.info['launchTime'] t = curTime self.lastT = self.t self.t = t deltaT = self.t - self.lastT self.deltaT = deltaT if self.hitBumper: pos = self.lastPos + self.lastVel * deltaT vel = self.lastVel self.lastVel += Vec3(0, 0, -32.0) * deltaT self.lastPos = pos toon.setFluidPos(pos) lastH = toon.getH() toon.setH(lastH + deltaT * self.angularVel) view = 0 else: pos = task.info['trajectory'].getPos(t) toon.setFluidPos(pos) shadowPos = Point3(pos) shadowPos.setZ(SHADOW_Z_OFFSET) self.dropShadow.setPos(shadowPos) vel = task.info['trajectory'].getVel(t) run = math.sqrt(vel[0] * vel[0] + vel[1] * vel[1]) rise = vel[2] theta = self.__toDegrees(math.atan(rise / run)) toon.setHpr(self.cannon.getH(render), -90 + theta, 0) view = 2 if pos.getZ() < -20 or pos.getZ() > 1000: self.notify.debug('stopping fly task toon.getZ()=%.2f' % pos.getZ()) self.__resetToonToCannon(self.av) return Task.done lookAt = task.info['toon'].getPos(render) hpr = task.info['toon'].getHpr(render) if self.localToonShooting: if view == 0: camera.wrtReparentTo(render) camera.lookAt(lookAt) elif view == 1: camera.reparentTo(render) camera.setPos(render, 100, 100, 35.25) camera.lookAt(render, lookAt) elif view == 2: if hpr[1] > -90: camera.setPos(0, 0, -30) if camera.getZ() < lookAt[2]: camera.setZ(render, lookAt[2] + 10) camera.lookAt(Point3(0, 0, 0)) self.__pickupTreasures(t) return Task.cont def __pickupTreasures(self, t): updatedList = [] for tList in self.hitTreasures: if t > tList[0]: messenger.send(tList[1].uniqueName('entertreasureSphere')) self.notify.debug('hit something!') else: updatedList.append(tList) self.hitTreasures = updatedList def __resetToonToCannon(self, avatar): pos = None if not avatar: if self.avId: avatar = base.cr.doId2do.get(self.avId, None) if avatar: if self.cannon: avatar.reparentTo(self.cannon) avatar.setPos(2, -4, 0) avatar.wrtReparentTo(render) self.__resetToon(avatar) return def __resetToon(self, avatar, pos = None): self.notify.debug('__resetToon') if avatar: self.__stopCollisionHandler(avatar) self.__setToonUpright(avatar, pos) if self.localToonShooting: self.notify.debug('toon setting position to %s' % pos) if pos: base.localAvatar.setPos(pos) camera.reparentTo(avatar) self.b_setLanded() def setActiveState(self, active): self.notify.debug('got setActiveState(%s)' % active) if active and not self.cannonsActive: self.activateCannons() elif not active and self.cannonsActive: self.deActivateCannons() def enterInit(self): self.nextKey = 'up' self.nextState = 'u1' def exitInit(self): pass def enteru1(self): self.nextKey = 'up' self.nextState = 'u2' def exitu1(self): pass def enteru2(self): self.nextKey = 'down' self.nextState = 'd3' def exitu2(self): pass def enterd3(self): self.nextKey = 'down' self.nextState = 'd4' def exitd3(self): pass def enterd4(self): self.nextKey = 'left' self.nextState = 'l5' def exitd4(self): pass def enterl5(self): self.nextKey = 'right' self.nextState = 'r6' def exitl5(self): pass def enterr6(self): self.nextKey = 'left' self.nextState = 'l7' def exitr6(self): pass def enterl7(self): self.nextKey = 'right' self.nextState = 'r8' def exitl7(self): pass def enterr8(self): self.nextKey = None self.nextState = '' self.codeFSM.request('acceptCode') return def exitr8(self): pass def enterAcceptCode(self): if not self.cannonsActive: self.activateCannons() self.sendUpdate('setActive', [1]) else: self.deActivateCannons() self.sendUpdate('setActive', [0]) self.codeFSM.request('init') def exitAcceptCode(self): pass def enterFinal(self): pass def exitFinal(self): pass def handleCodeKey(self, key): if self.nextKey and self.nextState: if key == self.nextKey: self.codeFSM.request(self.nextState) else: self.codeFSM.request('init') def incrementPinballInfo(self, score, multiplier): if base.localAvatar.doId == self.avId: self.curPinballScore += score self.curPinballMultiplier += multiplier self.notify.debug('score =%d multiplier=%d curscore=%d curMult=%d' % (score, multiplier, self.curPinballScore, self.curPinballMultiplier)) self.d_setPinballInfo() def d_setPinballInfo(self): self.notify.debug('d_setPinballInfo %d %d' % (self.curPinballScore, self.curPinballMultiplier)) target = base.cr.doId2do[self.targetId] target.b_setCurPinballScore(self.avId, self.curPinballScore, self.curPinballMultiplier) def createBlock(self, collisionName = None): gFormat = GeomVertexFormat.getV3c4() myVertexData = GeomVertexData('Cannon bumper vertices', gFormat, Geom.UHDynamic) vertexWriter = GeomVertexWriter(myVertexData, 'vertex') colorWriter = GeomVertexWriter(myVertexData, 'color') vertices = [(-1, 1, 1), (1, 1, 1), (1, -1, 1), (-1, -1, 1), (-1, 1, -1), (1, 1, -1), (1, -1, -1), (-1, -1, -1)] colors = [(0, 0, 0, 1), (0, 0, 1, 1), (0, 1, 0, 1), (0, 1, 1, 1), (1, 0, 0, 1), (1, 0, 1, 1), (1, 1, 0, 1), (1, 1, 1, 1)] faces = [(0, 2, 1), (0, 3, 2), (7, 4, 5), (6, 7, 5), (2, 3, 7), (2, 7, 6), (4, 0, 1), (5, 4, 1), (0, 4, 3), (3, 4, 7), (1, 2, 6), (1, 6, 5)] quads = [(3, 2, 1, 0), (4, 5, 6, 7), (3, 7, 6, 2), (0, 1, 5, 4), (0, 4, 7, 3), (1, 2, 6, 5)] for i in range(len(vertices)): vertex = vertices[i] vertexWriter.addData3f(vertex[0], vertex[1], vertex[2]) colorWriter.addData4f(*colors[i]) cubeGeom = Geom(myVertexData) tris = GeomTriangles(Geom.UHDynamic) tris.makeIndexed() for face in faces: for vertex in face: tris.addVertex(vertex) tris.closePrimitive() cubeGeom.addPrimitive(tris) cubeGN = GeomNode('cubeGeom') cubeGN.addGeom(cubeGeom) if collisionName: colNode = CollisionNode(collisionName) else: colNode = CollisionNode('cubeCollision') for quad in quads: colQuad = CollisionPolygon(Point3(*vertices[quad[0]]), Point3(*vertices[quad[1]]), Point3(*vertices[quad[2]]), Point3(*vertices[quad[3]])) colQuad.setTangible(0) colNode.addSolid(colQuad) block = NodePath('cubeNodePath') block.attachNewNode(cubeGN) block.attachNewNode(colNode) return block def loadCannonBumper(self): self.cannonBumper = loader.loadModel('phase_5.5/models/estate/bumper_cloud') self.cannonBumper.reparentTo(self.nodePath) self.cannonBumper.setScale(4.0) self.cannonBumper.setColor(0.52, 0.8, 0.98, 1) colCube = self.cannonBumper.find('**/collision') colCube.setName('cloudSphere-0') self.bumperCol = colCube self.notify.debug('------------self.cannonBumper.setPos %.2f %.2f %.2f' % (ToontownGlobals.PinballCannonBumperInitialPos[0], ToontownGlobals.PinballCannonBumperInitialPos[1], ToontownGlobals.PinballCannonBumperInitialPos[2])) self.cannonBumper.setPos(*ToontownGlobals.PinballCannonBumperInitialPos) def __bumperKeyPressed(self): self.notify.debug('__bumperKeyPressed') self.__bumperPressed() def __bumperPressed(self): renderPos = base.localAvatar.getPos(render) if renderPos[2] > 15.0: if not self.localToonShooting: return self.ignore(self.BUMPER_KEY) self.ignore(self.BUMPER_KEY2) self.notify.debug('renderPos %s' % renderPos) cannonPos = base.localAvatar.getPos(self.nodePath) self.notify.debug('cannonPos %s' % cannonPos) self.setCannonBumperPos(cannonPos[0], cannonPos[1], cannonPos[2]) self.requestBumperMove(cannonPos[0], cannonPos[1], cannonPos[2]) def requestBumperMove(self, x, y, z): self.sendUpdate('requestBumperMove', [x, y, z]) def setCannonBumperPos(self, x, y, z): self.notify.debug('------------setCannonBumperPos %f %f %f' % (x, y, z)) self.cannonBumper.setPos(x, y, z) self.bumperCol.setCollideMask(BitMask32.allOff()) taskMgr.doMethodLater(0.25, self.turnOnBumperCollision, self.uniqueName('BumperON')) def turnOnBumperCollision(self, whatever = 0): if self.bumperCol: self.bumperCol.setCollideMask(ToontownGlobals.WallBitmask)