from direct.directnotify import DirectNotifyGlobal from pandac.PandaModules import * from panda3d.toontown import * from toontown.toonbase.ToonBaseGlobal import * from .DistributedMinigame import * 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 import math from toontown.toon import ToonHead from . import PhotoGameGlobals from direct.gui.DirectGui import * from pandac.PandaModules import * from toontown.toonbase import TTLocalizer from toontown.golf import BuildGeometry from toontown.toon import Toon from toontown.toon import ToonDNA from direct.interval.IntervalGlobal import * import random from direct.showbase import PythonUtil import math import time from toontown.makeatoon import NameGenerator from otp.otpbase import OTPGlobals from toontown.battle import BattleParticles from toontown.minigame import PhotoGameBase WORLD_SCALE = 2.0 FAR_PLANE_DIST = 600 * WORLD_SCALE STAGE_Z_OFFSET = 7.0 GOODROWS = 13 BADROWS = 4 RAYSPREADX = 0.08 RAYSPREADY = 0.06 ZOOMRATIO = 0.4 ZOOMTIME = 0.5 WANTDOTS = 1 NUMSTARS = PhotoGameGlobals.NUMSTARS STARSIZE = 0.06 VIEWSIZEX = (GOODROWS - BADROWS) * RAYSPREADX VIEWSIZEY = (GOODROWS - BADROWS) * RAYSPREADY def toRadians(angle): return angle * 2.0 * math.pi / 360.0 def toDegrees(angle): return angle * 360.0 / (2.0 * math.pi) class DistributedPhotoGame(DistributedMinigame, PhotoGameBase.PhotoGameBase): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedPhotoGame') font = ToontownGlobals.getToonFont() LOCAL_PHOTO_MOVE_TASK = 'localPhotoMoveTask' FIRE_KEY = 'control' UP_KEY = 'arrow_up' DOWN_KEY = 'arrow_down' LEFT_KEY = 'arrow_left' RIGHT_KEY = 'arrow_right' INTRO_TASK_NAME = 'PhotoGameIntro' INTRO_TASK_NAME_CAMERA_LERP = 'PhotoGameIntroCamera' def __init__(self, cr): DistributedMinigame.__init__(self, cr) PhotoGameBase.PhotoGameBase.__init__(self) self.gameFSM = ClassicFSM.ClassicFSM('DistributedPhotoGame', [State.State('off', self.enterOff, self.exitOff, ['aim']), State.State('aim', self.enterAim, self.exitAim, ['showResults', 'cleanup', 'zoom']), State.State('zoom', self.enterZoom, self.exitZoom, ['showResults', 'cleanup', 'aim']), State.State('showResults', self.enterShowResults, self.exitShowResults, ['cleanup']), State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup') self.addChildGameFSM(self.gameFSM) self.tripod = None self.leftPressed = 0 self.rightPressed = 0 self.upPressed = 0 self.downPressed = 0 self.photoMoving = 0 self.introSequence = None self.subjects = [] self.scenery = [] self.subjectNode = render.attachNewNode('subjects') self.subjectTracks = {} self.nameCounter = 0 self.zoomedView = 0 self.zoomFlip = 1 self.cameraTrack = None self.assignments = [] self.currentAssignment = 0 self.assignmentPanels = [] self.toonList = [] self.assignmentDataDict = {} self.starDict = {} self.starParentDict = {} self.textureBuffers = [] self.filmCount = 20 self.edgeUp = 0 self.edgeRight = 0 self.edgeDown = 0 self.edgeLeft = 0 self.scorePanel = None return def getTitle(self): return TTLocalizer.PhotoGameTitle def getInstructions(self): return TTLocalizer.PhotoGameInstructions def getMaxDuration(self): return PhotoGameGlobals.GAME_TIME def load(self): self.notify.debug('load') DistributedMinigame.load(self) PhotoGameBase.PhotoGameBase.load(self) self.filmCount = self.data['FILMCOUNT'] self.safeZoneStorageDNAFile = self.data['DNA_TRIO'][0] self.storageDNAFile = self.data['DNA_TRIO'][1] self.dnaFile = self.data['DNA_TRIO'][2] self.dnaStore = DNAStorage() loader.loadDNAFile(self.dnaStore, 'phase_4/dna/storage.dna') loader.loadDNAFile(self.dnaStore, self.storageDNAFile) loader.loadDNAFile(self.dnaStore, self.safeZoneStorageDNAFile) node = loader.loadDNAFile(self.dnaStore, self.dnaFile) self.scene = hidden.attachNewNode(node) self.construct() purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui') self.filmImage = loader.loadModel('phase_4/models/minigames/photogame_filmroll') self.filmImage.reparentTo(hidden) self.tripodModel = loader.loadModel('phase_4/models/minigames/toon_cannon') self.filmPanel = DirectLabel(parent=hidden, relief=None, pos=(1.16, 0.0, 0.45), scale=0.65, text=str(self.filmCount), text_scale=0.2, text_fg=(0.95, 0.95, 0, 1), text_pos=(0.08, -0.15), text_font=ToontownGlobals.getSignFont(), image=self.filmImage, image_scale=Point3(1.0, 0.0, 0.85)) self.filmPanelTitle = DirectLabel(parent=self.filmPanel, relief=None, pos=(0.08, 0, 0.04), scale=0.08, text=TTLocalizer.PhotoGameFilm, text_fg=(0.95, 0.95, 0, 1), text_shadow=(0, 0, 0, 1)) self.music = base.loader.loadMusic('phase_4/audio/bgm/MG_cannon_game.ogg') self.sndPhotoMove = base.loader.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.ogg') self.sndPhotoFire = base.loader.loadSfx('phase_4/audio/sfx/MG_cannon_fire_alt.ogg') self.sndWin = base.loader.loadSfx('phase_4/audio/sfx/MG_win.ogg') self.sndFilmTick = base.loader.loadSfx('phase_4/audio/sfx/Photo_instamatic.ogg') self.timer = ToontownTimer.ToontownTimer() self.timer.posInTopRightCorner() self.timer.hide() self.viewfinderNode = base.aspect2d.attachNewNode('camera node') self.viewfinderNode.setTransparency(TransparencyAttrib.MAlpha) self.viewfinderNode.setDepthWrite(1) self.viewfinderNode.setDepthTest(1) self.viewfinderNode.setY(-1.0) self.screenSizeMult = 0.5 self.screenSizeX = (base.a2dRight - base.a2dLeft) * self.screenSizeMult self.screenSizeZ = (base.a2dTop - base.a2dBottom) * self.screenSizeMult viewfinderImage = loader.loadModel('phase_4/models/minigames/photo_game_viewfinder') viewfinderImage.reparentTo(self.viewfinderNode) viewfinderImage.setScale(0.55, 1.0, 0.55) self.blackoutNode = base.aspect2d.attachNewNode('blackout node') self.blackoutNode.setP(90) BuildGeometry.addSquareGeom(self.blackoutNode, self.screenSizeX * 2.2, self.screenSizeZ * 2.2, Vec4(1.0, 1.0, 1.0, 1.0)) self.blackoutNode.setTransparency(TransparencyAttrib.MAlpha) self.blackoutNode.setColorScale(0.0, 0.0, 0.0, 0.5) self.blackoutNode.setDepthWrite(1) self.blackoutNode.setDepthTest(1) self.blackoutNode.hide() self.subjectToon = Toon.Toon() self.addSound('zoom', 'Photo_zoom.ogg', 'phase_4/audio/sfx/') self.addSound('snap', 'Photo_shutter.ogg', 'phase_4/audio/sfx/') return def __setupCapture(self): self.captureCam = NodePath(Camera('CaptureCamera')) self.captureCam.reparentTo(self.pointer) self.captureLens = PerspectiveLens() self.captureOutFOV = VIEWSIZEX / self.screenSizeX * self.outFov * 0.5 self.captureZoomFOV = VIEWSIZEX / self.screenSizeX * self.zoomFov * 0.5 self.captureLens.setFov(self.captureOutFOV) self.captureLens.setAspectRatio(1.33) self.captureCam.node().setLens(self.captureLens) def __removeCapture(self): del self.captureCam del self.captureLens def unload(self): self.notify.debug('unload') DistributedMinigame.unload(self) if self.cameraTrack: self.cameraTrack.finish() self.cameraTrack = None self.__removeCapture() for textureBuffer in self.textureBuffers: base.graphicsEngine.removeWindow(textureBuffer) del self.textureBuffers self.viewfinderNode.removeNode() self.blackoutNode.removeNode() for key in self.assignmentDataDict: assignmentData = self.assignmentDataDict[key] assignmentData[7].delete() del self.assignmentDataDict self.assignments = [] for subject in self.subjects: subject.delete() self.subjects = [] self.subjectToon.delete() self.destruct() for scenery in self.scenery: scenery.removeNode() self.scenery = None self.subjectNode.removeNode() self.subjectNode = None self.sky.removeNode() del self.sky self.photoRoot = None self.scene.removeNode() del self.scene self.pointer.removeNode() self.tripodModel.removeNode() del self.tripodModel for panel in self.assignmentPanels: panel.destroy() self.assignmentPanels = [] if self.scorePanel: self.scorePanel.destroy() self.starDict = {} self.starParentDict = {} self.filmPanel.destroy() del self.filmPanel self.filmImage.removeNode() del self.filmImage del self.music del self.sndPhotoMove del self.sndPhotoFire del self.sndWin del self.sndFilmTick self.tripod.removeNode() del self.tripod del self.swivel self.timer.destroy() del self.timer self.removeChildGameFSM(self.gameFSM) del self.gameFSM self.ignoreAll() return def onstage(self): self.notify.debug('Onstage') DistributedMinigame.onstage(self) self.__createTripod() self.tripod.reparentTo(render) self.tripod.hide() self.__loadToonInTripod(self.localAvId) camera.reparentTo(render) self.__oldCamFar = base.camLens.getFar() base.camLens.setFar(FAR_PLANE_DIST) self.__setupSubjects() self.__startIntro() base.transitions.irisIn() base.playMusic(self.music, looping=1, volume=0.8) orgFov = base.camLens.getFov() self.outFov = orgFov.getX() self.zoomFov = orgFov.getX() * ZOOMRATIO self.currentFov = self.outFov self.__setupCapture() def offstage(self): self.notify.debug('offstage') self.sky.reparentTo(hidden) self.scene.reparentTo(hidden) for avId in self.avIdList: av = self.getAvatar(avId) if av: av.dropShadow.show() av.resetLOD() self.__stopIntro() base.camLens.setFar(self.__oldCamFar) self.timer.reparentTo(hidden) self.filmPanel.reparentTo(hidden) DistributedMinigame.offstage(self) for key in self.subjectTracks: track = self.subjectTracks[key][0] track.pause() del track self.subjectTracks = {} base.localAvatar.laffMeter.start() del self.soundTable def __setupCollisions(self): self.queue = CollisionHandlerQueue() self.traverser = CollisionTraverser('traverser name') self.rayArray = [] vRange = (GOODROWS - BADROWS) // 2 for row in range(-(GOODROWS // 2), GOODROWS // 2 + 1): for column in range(-(GOODROWS // 2), GOODROWS // 2 + 1): goodRange = list(range(-((GOODROWS - BADROWS) // 2), (GOODROWS - BADROWS) // 2 + 1)) rayQuality = 'g' if row not in goodRange or column not in goodRange: rayQuality = 'l' if row > vRange: rayQuality = 'r' if column > vRange: rayQuality = 't' if column < -vRange: rayQuality = 'b' columnString = '+%s' % column if column < 0: columnString = '%s' % column rowString = '+%s' % row if row < 0: rowString = '%s' % row pickerNode = CollisionNode('%s %s %s' % (rowString, columnString, rayQuality)) pickerNP = camera.attachNewNode(pickerNode) pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) pickerRay = CollisionRay() pickerNode.addSolid(pickerRay) self.rayArray.append((row, column, pickerNode, pickerNP, pickerRay)) self.traverser.addCollider(pickerNP, self.queue) if WANTDOTS: self.markerDict = {} for rayEntry in self.rayArray: markerNode = self.viewfinderNode.attachNewNode('marker Node') BuildGeometry.addSquareGeom(markerNode, 0.01, 0.01, Vec4(1.0, 1.0, 1.0, 1.0)) markerNode.setX(RAYSPREADX * rayEntry[0]) markerNode.setY(RAYSPREADY * rayEntry[1]) markerNode.setDepthWrite(1) markerNode.setZ(2.0) self.markerDict[rayEntry[0], rayEntry[1]] = markerNode self.lensNode = LensNode('photo taker') self.lensNode.setLens(base.camLens) def __moveViewfinder(self, task): if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() self.viewfinderNode.setX(mpos.getX() * self.screenSizeX) self.viewfinderNode.setZ(mpos.getY() * self.screenSizeZ) horzAngle = self.viewfinderNode.getX() / self.screenSizeX * 0.5 * base.camLens.getFov()[0] vertAngle = self.viewfinderNode.getZ() / self.screenSizeZ * 0.5 * base.camLens.getFov()[1] horzPointFlat = self.viewfinderNode.getX() / self.screenSizeX vertPointFlat = self.viewfinderNode.getZ() / self.screenSizeZ horzLength = base.camLens.getFov()[0] * 0.5 vertLength = base.camLens.getFov()[1] * 0.5 horzRadianLength = toRadians(horzLength) vertRadianLength = toRadians(vertLength) hMRadian = math.atan(horzPointFlat * math.tan(horzRadianLength)) vMRadian = math.atan(vertPointFlat * math.tan(vertRadianLength)) hMDegree = toDegrees(hMRadian) vMDegree = toDegrees(vMRadian) self.pointer.setH(-hMDegree) self.pointer.setP(vMDegree) newRight = 0 newLeft = 0 newUp = 0 newDown = 0 if self.viewfinderNode.getX() > self.screenSizeX * 0.95: newRight = 1 if self.viewfinderNode.getX() < self.screenSizeX * -0.95: newLeft = 1 if self.viewfinderNode.getZ() > self.screenSizeZ * 0.95: newUp = 1 if self.viewfinderNode.getZ() < self.screenSizeZ * -0.95: newDown = 1 if not self.edgeRight and newRight: self.edgeRight = 1 self.__rightPressed() elif self.edgeRight and not newRight: self.edgeRight = 0 self.__rightReleased() if not self.edgeLeft and newLeft: self.edgeLeft = 1 self.__leftPressed() elif self.edgeLeft and not newLeft: self.edgeLeft = 0 self.__leftReleased() if not self.edgeUp and newUp: self.edgeUp = 1 self.__upPressed() elif self.edgeUp and not newUp: self.edgeUp = 0 self.__upReleased() if not self.edgeDown and newDown: self.edgeDown = 1 self.__downPressed() elif self.edgeDown and not newDown: self.edgeDown = 0 self.__downReleased() return task.cont def __testCollisions(self): self.notify.debug('\nSnapping Photo') self.playSound('snap') if self.filmCount <= 0: self.notify.debug('No Film') return for rayEntry in self.rayArray: posX = (self.viewfinderNode.getX() + RAYSPREADX * rayEntry[0]) / self.screenSizeX posY = (self.viewfinderNode.getZ() + RAYSPREADY * rayEntry[1]) / self.screenSizeZ rayEntry[4].setFromLens(self.lensNode, posX, posY) self.traverser.traverse(self.subjectNode) distDict = {} hitDict = {} centerDict = {} for i in range(self.queue.getNumEntries()): entry = self.queue.getEntry(i) object = None objectIndex = None subjectIndexString = entry.getIntoNodePath().getNetTag('subjectIndex') sceneryIndexString = entry.getIntoNodePath().getNetTag('sceneryIndex') if subjectIndexString: objectIndex = int(subjectIndexString) object = self.subjects[objectIndex] elif sceneryIndexString: objectIndex = int(sceneryIndexString) object = self.scenery[objectIndex] marker = 'g' if 'b' in entry.getFromNodePath().getName(): marker = 'b' if 't' in entry.getFromNodePath().getName(): marker = 't' if 'r' in entry.getFromNodePath().getName(): marker = 'r' if 'l' in entry.getFromNodePath().getName(): marker = 'l' if object: newEntry = (entry.getFromNode(), object) distance = Vec3(entry.getSurfacePoint(self.tripod)).lengthSquared() name = entry.getFromNode().getName() if name not in distDict: distDict[name] = distance hitDict[name] = (entry.getFromNode(), object, marker) elif distance < distDict[name]: distDict[name] = distance hitDict[name] = (entry.getFromNode(), object, marker) for key in hitDict: hit = hitDict[key] superParent = hit[1] marker = hit[2] onCenter = 0 overB = 0 overT = 0 overR = 0 overL = 0 quality = -1 if marker == 'b': overB = 1 elif marker == 't': overT = 1 elif marker == 'r': overR = 1 elif marker == 'l': overL = 1 else: quality = 1 onCenter = 1 if superParent not in centerDict: centerDict[superParent] = (onCenter, overB, overT, overR, overL) else: centerDict[superParent] = (onCenter + centerDict[superParent][0], overB + centerDict[superParent][1], overT + centerDict[superParent][2], overR + centerDict[superParent][3], overL + centerDict[superParent][4]) if WANTDOTS: for key in self.markerDict: node = self.markerDict[key] node.setColorScale(Vec4(1, 1, 1, 1)) for key in hitDict: entry = hitDict[key] name = entry[0].getName() xS = int(name[0:2]) yS = int(name[3:5]) node = self.markerDict[xS, yS] node.setColorScale(Vec4(1.0, 0.0, 0.0, 1.0)) centerDictKeys = [] for key in centerDict: centerDictKeys.append(key) for subject in centerDictKeys: score = self.judgePhoto(subject, centerDict) self.notify.debug('Photo is %s / 5 stars' % score) self.notify.debug('assignment compare %s %s' % (self.determinePhotoContent(subject), self.assignments[self.currentAssignment])) content = self.determinePhotoContent(subject) if content: photoAnalysisZero = (content[0], content[1]) if score and photoAnalysisZero in self.assignments: index = self.assignments.index(photoAnalysisZero) assignment = self.assignments[index] self.notify.debug('assignment complete') if score >= self.assignmentDataDict[assignment][0]: subjectIndex = self.subjects.index(subject) texturePanel = self.assignmentDataDict[assignment][5] texture = self.assignmentDataDict[assignment][6] buffer = self.assignmentDataDict[assignment][4] panelToon = self.assignmentDataDict[assignment][7] panelToon.hide() buffer.setActive(1) texturePanel.show() texturePanel.setColorScale(1, 1, 1, 1) taskMgr.doMethodLater(0.2, buffer.setActive, 'capture Image', [0]) if score > self.assignmentDataDict[assignment][0]: self.assignmentDataDict[assignment][0] = score self.updateAssignmentPanels() self.sendUpdate('newClientPhotoScore', [subjectIndex, content[1], score]) else: self.notify.debug('assignment not complete') horzAngle = self.viewfinderNode.getX() / self.screenSizeX * 0.5 * base.camLens.getFov()[0] vertAngle = self.viewfinderNode.getZ() / self.screenSizeZ * 0.5 * base.camLens.getFov()[1] horzPointFlat = self.viewfinderNode.getX() / self.screenSizeX vertPointFlat = self.viewfinderNode.getZ() / self.screenSizeZ horzLength = base.camLens.getFov()[0] * 0.5 vertLength = base.camLens.getFov()[1] * 0.5 horzRadianLength = toRadians(horzLength) vertRadianLength = toRadians(vertLength) hMRadian = math.atan(horzPointFlat * math.tan(horzRadianLength)) vMRadian = math.atan(vertPointFlat * math.tan(vertRadianLength)) hMDegree = toDegrees(hMRadian) vMDegree = toDegrees(vMRadian) self.__decreaseFilmCount() if self.filmCount == 0: self.sendUpdate('filmOut', []) self.notify.debug('Screen angles H:%s V:%s' % (self.swivel.getH(), self.swivel.getP())) self.notify.debug('Viewfinder to screen angles H:%s V:%s' % (horzAngle, vertAngle)) self.notify.debug('Viewfinder to screen angles with math H:%s V:%s' % (hMDegree, vMDegree)) return def newAIPhotoScore(self, playerId, assignmentIndex, score): if len(self.assignments) > assignmentIndex: assignment = self.assignments[assignmentIndex] assignmentData = self.assignmentDataDict[assignment] if score > assignmentData[2]: assignmentData[2] = score assignmentData[3] = playerId self.updateAssignmentPanels() def determinePhotoContent(self, subject): if self.getSubjectTrackState(subject): return [subject, self.getSubjectTrackState(subject)[2]] else: return None return None def judgePhoto(self, subject, centerDict): self.notify.debug('judgePhoto') self.notify.debug(subject.getName()) self.notify.debug(str(centerDict[subject])) a1 = camera.getH(render) % 360 a2 = subject.getH(render) % 360 angle = abs((a1 + 180 - a2) % 360 - 180) self.notify.debug('angle camera:%s subject:%s between:%s' % (camera.getH(render), subject.getH(render), angle)) self.notify.debug(str(angle)) centering = centerDict[subject] if type(subject) == type(self.subjectToon): facing = angle / 180.0 interest = self.getSubjectTrackState(subject)[3] quality = centering[0] - (centering[1] + centering[2] + centering[3] + centering[4]) tooClose = centering[1] and centering[2] or centering[3] and centering[4] portrait = centering[1] and not (centering[2] or centering[3] or centering[4]) self.notify.debug('angle %s facing %s' % (angle, facing)) self.notify.debug('Interest %s' % interest) self.notify.debug('Quality %s' % quality) self.notify.debug('tooClose %s' % tooClose) if quality <= 0: return None else: score = 0 if angle >= 135: score += 2 elif angle >= 90: score += 1 elif angle <= 60: score -= 1 score += interest if quality >= 5 and (not tooClose or portrait): score += 1 if quality >= 10: score += 1 if quality >= 15: score += 1 score -= 2 if score > NUMSTARS: score = float(NUMSTARS) if score <= 0: return 1 else: return score return None def __toggleView(self): self.notify.debug('Toggle View') hCam = self.swivel.getH() vCam = self.swivel.getP() horzPointFlat = self.viewfinderNode.getX() / self.screenSizeX vertPointFlat = self.viewfinderNode.getZ() / self.screenSizeZ horzLength = base.camLens.getFov()[0] * 0.5 vertLength = base.camLens.getFov()[1] * 0.5 horzRadianLength = toRadians(horzLength) vertRadianLength = toRadians(vertLength) hMRadian = math.atan(horzPointFlat * math.tan(horzRadianLength)) vMRadian = math.atan(vertPointFlat * math.tan(vertRadianLength)) hMDegree = toDegrees(hMRadian) vMDegree = toDegrees(vMRadian) if self.zoomedView: self.zoomedView = 0 else: self.zoomedView = 1 if self.zoomedView: self.notify.debug('Zoom In') hMove = hMDegree * (1.0 - ZOOMRATIO) vMove = vMDegree * (1.0 - ZOOMRATIO) self.currentFov = self.zoomFov base.camLens.setFov(self.zoomFov) self.blackoutNode.show() self.swivel.setHpr(self.swivel, hMove * -self.zoomFlip, vMove * self.zoomFlip, 0) else: self.notify.debug('Zoom Out') hMove = hMDegree * ((1.0 - ZOOMRATIO) / ZOOMRATIO) vMove = vMDegree * ((1.0 - ZOOMRATIO) / ZOOMRATIO) self.currentFov = self.outFov base.camLens.setFov(self.outFov) self.blackoutNode.hide() self.swivel.setHpr(self.swivel, hMove * self.zoomFlip, vMove * -self.zoomFlip, 0) def __doZoom(self): self.notify.debug('Toggle View') self.playSound('zoom') hCam = self.swivel.getH() vCam = self.swivel.getP() horzPointFlat = self.viewfinderNode.getX() / self.screenSizeX vertPointFlat = self.viewfinderNode.getZ() / self.screenSizeZ horzLength = base.camLens.getFov()[0] * 0.5 vertLength = base.camLens.getFov()[1] * 0.5 horzRadianLength = toRadians(horzLength) vertRadianLength = toRadians(vertLength) hMRadian = math.atan(horzPointFlat * math.tan(horzRadianLength)) vMRadian = math.atan(vertPointFlat * math.tan(vertRadianLength)) hMDegree = toDegrees(hMRadian) vMDegree = toDegrees(vMRadian) if self.zoomedView: self.zoomedView = 0 else: self.zoomedView = 1 self.cameraTrack = Sequence() if self.zoomedView: self.notify.debug('Zoom In') hMove = hMDegree * (1.0 - ZOOMRATIO) vMove = vMDegree * (1.0 - ZOOMRATIO) self.currentFov = self.zoomFov base.camLens.setFov(self.zoomFov) self.blackoutNode.show() orgQuat = self.swivel.getQuat() self.swivel.setHpr(self.swivel, hMove * -self.zoomFlip, vMove * self.zoomFlip, 0) self.swivel.setR(0.0) newQuat = self.swivel.getQuat() self.swivel.setQuat(orgQuat) zoomTrack = Parallel() zoomTrack.append(LerpQuatInterval(self.swivel, ZOOMTIME, newQuat)) zoomTrack.append(LerpFunc(base.camLens.setFov, fromData=self.outFov, toData=self.zoomFov, duration=ZOOMTIME)) zoomTrack.append(LerpFunc(self.setBlackout, fromData=0.0, toData=0.5, duration=ZOOMTIME)) self.cameraTrack.append(zoomTrack) self.cameraTrack.append(Func(self.finishZoom, 1)) else: self.notify.debug('Zoom Out') hMove = hMDegree * ((1.0 - ZOOMRATIO) / ZOOMRATIO) vMove = vMDegree * ((1.0 - ZOOMRATIO) / ZOOMRATIO) self.currentFov = self.outFov base.camLens.setFov(self.outFov) orgQuat = self.swivel.getQuat() self.swivel.setHpr(self.swivel, hMove * self.zoomFlip, vMove * -self.zoomFlip, 0) self.swivel.setR(0.0) newQuat = self.swivel.getQuat() self.swivel.setQuat(orgQuat) zoomTrack = Parallel() zoomTrack.append(LerpQuatInterval(self.swivel, ZOOMTIME, newQuat)) zoomTrack.append(LerpFunc(base.camLens.setFov, fromData=self.zoomFov, toData=self.outFov, duration=ZOOMTIME)) zoomTrack.append(LerpFunc(self.setBlackout, fromData=0.5, toData=0.0, duration=ZOOMTIME)) self.cameraTrack.append(zoomTrack) self.cameraTrack.append(Func(self.blackoutNode.hide)) self.cameraTrack.append(Func(self.finishZoom, 0)) self.cameraTrack.start() def setBlackout(self, black): self.blackoutNode.setColorScale(0.0, 0.0, 0.0, black) def getSubjectTrackState(self, subject): subjectTrack = self.subjectTracks.get(subject) if subjectTrack: interval = subjectTrack[0] timeline = subjectTrack[1] time = interval.getT() timeCount = time timelineIndex = 0 while timeCount >= 0.0: timeCount -= timeline[timelineIndex][1] if timeCount >= 0.0: timelineIndex += 1 return timeline[timelineIndex] else: return None return None def __setupSubjects(self): self.__setupCollisions() self.subjects = [] self.subjectTracks = {} self.photoRoot.reparentTo(self.subjectNode) self.photoRoot.setTag('sceneryIndex', '%s' % len(self.scenery)) self.scenery.append(self.photoRoot) random.seed(time.time()) namegen = NameGenerator.NameGenerator() for pathIndex in range(len(self.data['PATHS'])): path = self.data['PATHS'][pathIndex] subject = Toon.Toon() gender = random.choice(['m', 'f']) seed = int(random.random() * 571) if gender == 'm': boy = 1 girl = 0 else: boy = 0 girl = 1 subject.setName(namegen.randomNameMoreinfo(boy=boy, girl=girl)[-1]) self.nameCounter += 1 subject.setPickable(0) subject.setPlayerType(NametagGroup.CCNonPlayer) dna = ToonDNA.ToonDNA() dna.newToonRandom(seed, gender, 1) subject.setDNAString(dna.makeNetString()) subject.animFSM.request('neutral') subject.setTag('subjectIndex', '%s' % len(self.subjects)) self.subjects.append(subject) height = subject.getHeight() self.collSphere = CollisionSphere(0, 0, height * 0.5, height * 0.5) self.collSphere.setTangible(1) self.collNode = CollisionNode(self.uniqueName('subject Sphere')) self.collNode.setCollideMask(BitMask32.allOn()) self.collNode.addSolid(self.collSphere) self.collNodePath = subject.attachNewNode(self.collNode) subject.reparentTo(self.subjectNode) subject.setPos(path[0]) subject.lookAt(path[1]) subject.show() subjectTrack = self.generateToonTrack(subject, path, pathIndex) subjectTrack[0].start() self.subjectTracks[subject] = subjectTrack def regenerateToonTrack(self, subject, path, pathIndex): if not hasattr(self, 'swivel'): return subjectTrack = self.generateToonTrack(subject, path, pathIndex) subjectTrack[0].start() self.subjectTracks[subject] = subjectTrack def generateToonTrack(self, subject, path, pathIndex): def getNextIndex(curIndex, path): return (curIndex + 1) % len(path) subjectTrack = Sequence() subjectTimeline = [] timeAccum = 0.0 pathPointIndex = 0 orgPos = subject.getPos() orgQuat = subject.getQuat() while pathPointIndex < len(path): nextIndex = getNextIndex(pathPointIndex, path) curPoint = path[pathPointIndex] nextPoint = path[nextIndex] distance = self.slowDistance(curPoint, nextPoint) pointTime = distance * 0.25 subject.setPos(curPoint) subject.lookAt(nextPoint) nextQuat = subject.getQuat() animSetIndex = self.data['PATHANIMREL'][pathIndex] animChoice = random.choice(self.data['ANIMATIONS'][animSetIndex])[0] movetype = random.choice(self.data['MOVEMODES'][animSetIndex]) turnTime = 0.2 if movetype[0] == 'swim': turnTime = 0.0 nextInterval = LerpQuatInterval(subject, turnTime, quat=nextQuat) subjectTrack.append(nextInterval) subjectTimeline.append((timeAccum, nextInterval.getDuration(), 'turn', 1.0)) timeAccum += nextInterval.getDuration() movetype = random.choice(self.data['MOVEMODES'][animSetIndex]) pointTime = pointTime * movetype[1] if movetype[0] == 'swim': nextInterval = Sequence() startInterval = Func(subject.setP, -60) midInterval = Parallel(LerpPosInterval(subject, pointTime, nextPoint), ActorInterval(subject, movetype[0], loop=1, duration=pointTime)) nextInterval.append(startInterval) nextInterval.append(midInterval) else: nextInterval = Sequence() startInterval = Func(subject.setP, 0) midInterval = Parallel(LerpPosInterval(subject, pointTime, nextPoint), ActorInterval(subject, movetype[0], loop=1, duration=pointTime)) nextInterval.append(startInterval) nextInterval.append(midInterval) subjectTrack.append(nextInterval) subjectTimeline.append((timeAccum, nextInterval.getDuration(), movetype[0], 1.0)) timeAccum += nextInterval.getDuration() if animChoice: nextInterval = ActorInterval(subject, animChoice, loop=0) subjectTrack.append(nextInterval) subjectTimeline.append((timeAccum, nextInterval.getDuration(), animChoice, 2.0)) timeAccum += nextInterval.getDuration() pathPointIndex += 1 subject.setPos(orgPos) subject.setQuat(orgQuat) subjectTrack.append(Func(self.regenerateToonTrack, subject, path, pathIndex)) return (subjectTrack, subjectTimeline) def slowDistance(self, point1, point2): dx = point1[0] - point2[0] dy = point1[1] - point2[1] dz = point1[2] - point2[2] distance = math.sqrt(dx * dx + dy * dy + dz * dz) return distance def getNextPoint(self, pointList, point): pointIndex = 0 length = len(pointList) found = 0 loop = 0 while not found and loop < length: if pointList[index] == point: found = 1 else: index += 1 loop += 1 if not found: return None nextPointIndex = loop + 1 if nextPointIndex >= length: nextPointIndex = 0 return pointList[nextPointIndex] def __createTripod(self): tripod = self.tripodModel.copyTo(hidden) swivel = tripod.find('**/cannon') self.tripod = tripod self.swivel = swivel self.pointer = self.swivel.attachNewNode('pointer') self.tripod.setPos(self.photoRoot.getPos()) self.tripod.setPos(self.tripod.getPos() + self.data['TRIPOD_OFFSET']) def setGameReady(self): if not self.hasLocalToon: return self.notify.debug('setGameReady') if DistributedMinigame.setGameReady(self): return def setGameStart(self, timestamp): if not self.hasLocalToon: return self.notify.debug('setGameStart') DistributedMinigame.setGameStart(self, timestamp) self.__stopIntro() self.__putCameraOnTripod() if not base.config.GetBool('endless-cannon-game', 0): self.timer.show() self.timer.countdown(self.data['TIME'], self.__gameTimerExpired) self.filmPanel.reparentTo(aspect2d) self.scoreMult = MinigameGlobals.getScoreMult(self.cr.playGame.hood.id) self.clockStopTime = None self.gameFSM.request('aim') self.__putCameraOnTripod() self.currentAssignment = 0 assignmentTemplates = self.generateAssignmentTemplates(PhotoGameGlobals.ONSCREENASSIGNMENTS) self.generateAssignments(assignmentTemplates) self.generateAssignmentPanels() self.scorePanel = self.makeScoreFrame() self.scorePanel.reparentTo(aspect2d) self.scorePanel.setPos(1.05, 0.0, -0.725) self.updateAssignmentPanels() for subject in self.subjects: subject.useLOD(1000) return def setGameExit(self): DistributedMinigame.setGameExit(self) self.__gameTimerExpired() def __gameTimerExpired(self): self.notify.debug('game timer expired') self.gameOver() def generateAssignments(self, assignmentTemplates): for template in assignmentTemplates: subject = self.subjects[template[0]] pose = template[1] score = 0.0 panel = None topScore = 0.0 topScorerId = None textureBuffer = None texturePanel = None texture = None panelToon = None assignment = (subject, pose) if assignment not in self.assignments: self.assignments.append(assignment) self.assignmentDataDict[assignment] = [score, panel, topScore, topScorerId, textureBuffer, texturePanel, texture, panelToon] self.notify.debug('assignments') for assignment in self.assignments: self.notify.debug(str(assignment)) return def generateAssignmentPanels(self): self.notify.debug('generateAssignmentPanels') for panel in self.assignmentPanels: panel.destroy() spacing = self.screenSizeX / PhotoGameGlobals.ONSCREENASSIGNMENTS * 1.61 index = 0 Xoff = self.screenSizeX - 0.735 Zoff = -self.screenSizeZ + 0.25 for assignment in self.assignments: self.notify.debug('made assignment panel %s' % str(assignment)) panel, texturePanel, toon = self.makeAssignmentPanel(assignment) panel.setX(Xoff - spacing * index) panel.setZ(Zoff) texturePanel.setZ(0.065) rot = random.choice([0.0, 2.0, -2.0, -4.0, 6.0]) panel.setR(rot) textureBuffer = base.win.makeTextureBuffer('Photo Capture', 128, 128) dr = textureBuffer.makeDisplayRegion() dr.setCamera(self.captureCam) texture = textureBuffer.getTexture() texturePanel.setTexture(texture) texturePanel.setColorScale(0, 0, 0, 0) textureBuffer.setActive(0) self.textureBuffers.append(textureBuffer) texturePanel.hide() self.assignmentPanels.append(panel) self.assignmentDataDict[assignment][1] = panel self.assignmentDataDict[assignment][4] = textureBuffer self.assignmentDataDict[assignment][5] = texturePanel self.assignmentDataDict[assignment][6] = texture self.assignmentDataDict[assignment][7] = toon index += 1 def printAD(self): for assignment in self.assignmentDataDict: data = self.assignmentDataDict[assignment] print('Key:%s\nData:%s\n' % (str(assignment), data)) def updateScorePanel(self): teamScore = 0.0 bonusScore = 0.0 for assignment in self.assignments: data = self.assignmentDataDict[assignment] teamScore += data[2] if data[3] == localAvatar.doId: bonusScore += 1.0 self.scorePanel['text'] = TTLocalizer.PhotoGameScore % (int(teamScore), int(bonusScore), int(teamScore + bonusScore)) def updateAssignmentPanels(self): for assignment in self.assignments: data = self.assignmentDataDict[assignment] leaderName = data[3] leader = base.cr.doId2do.get(data[3]) if not leader: data[1]['text'] = ' ' elif leader.doId == localAvatar.doId: data[1]['text'] = TTLocalizer.PhotoGameScoreYou else: leaderName = leader.getName() data[1]['text'] = TTLocalizer.PhotoGameScoreOther % leaderName starList = self.starDict[data[1]] starParent = self.starParentDict[data[1]] score = int(data[2]) for index in range(NUMSTARS): if index < score: starList[index].show() else: starList[index].hide() starParent.setX(float(NUMSTARS - score) * STARSIZE * 0.5) self.updateScorePanel() def makeAssignmentPanel(self, assignment): if assignment != None: assignedToon = Toon.Toon() assignedToon.setDNA(assignment[0].getStyle()) else: assignedToon = None model, ival = self.makeFrameModel(assignedToon) if assignedToon: assignedToon.loop(assignment[1]) model.reparentTo(aspect2d) assignedToon.setH(172) assignedToon.setZ(-1.2) assignedToon.setY(100.0) if assignment[1] == 'swim': assignedToon.setP(-70) assignedToon.setH(160) assignedToon.setZ(-0.6) model.setH(0) model.setScale(1.0) model['text'] = ' ' assignedToon.setY(-100.0) model.setY(-10.0) screen = model.attachNewNode('screen node') BuildGeometry.addSquareGeom(screen, 0.36, 0.27, Vec4(1.0, 1.0, 1.0, 1.0)) screen.setHpr(0, 90, 0) screen.setDepthTest(1) starImage = loader.loadModel('phase_4/models/minigames/photogame_star') starParent = model.attachNewNode('star parent') self.starDict[model] = [] for index in range(NUMSTARS): star = DirectLabel(parent=starParent, image=starImage, image_color=(1, 1, 1, 1), image_scale=Point3(STARSIZE, 0.0, STARSIZE), relief=None) star.setX(STARSIZE * -0.5 * float(NUMSTARS) + float(index + 0.5) * STARSIZE) star.setZ(-0.05 - STARSIZE) self.starDict[model].append(star) self.starParentDict[model] = starParent star.hide() return (model, screen, assignedToon) def makeFrameModel(self, model): frame = self.makeAssignmentFrame() ival = None if model: model.setDepthTest(1) model.setDepthWrite(1) scale = frame.attachNewNode('scale') model.reparentTo(scale) bMin, bMax = model.getTightBounds() center = (bMin + bMax) / 2.0 model.setPos(-center[0], 2, -center[2]) corner = Vec3(bMax - center) scaleFactor = self.screenSizeX / PhotoGameGlobals.ONSCREENASSIGNMENTS scale.setScale(0.4 * scaleFactor / max(corner[0], corner[1], corner[2])) return (frame, ival) def makeAssignmentFrame(self): from direct.gui.DirectGui import DirectFrame photoImage = loader.loadModel('phase_4/models/minigames/photo_game_pictureframe') size = 1.0 assignmentScale = self.screenSizeX / PhotoGameGlobals.ONSCREENASSIGNMENTS frame = DirectFrame(parent=hidden, image=photoImage, image_color=(1, 1, 1, 1), image_scale=Point3(1.6 * assignmentScale, 0.0, 1.75 * assignmentScale), frameSize=(-size, size, -size, size), text='HC Score', textMayChange=1, text_wordwrap=9, text_pos=Point3(0.0, -0.135, 0.0), text_scale=0.045, relief=None) return frame def makeScoreFrame(self): from direct.gui.DirectGui import DirectFrame size = 1.0 scoreImage = loader.loadModel('phase_4/models/minigames/photogame_camera') frame = DirectFrame(parent=hidden, image=scoreImage, image_color=(1, 1, 1, 1), image_scale=Point3(0.64, 0.0, 0.64), frameSize=(-size, size, -size, size), text='Score Frame', textMayChange=1, text_wordwrap=9, text_pos=Point3(0.0, 0.0, 0.0), text_scale=0.05, relief=None) return frame def enterOff(self): self.notify.debug('enterOff') def exitOff(self): pass def enterAim(self): self.notify.debug('enterAim') self.__enableAimInterface() taskMgr.add(self.__moveViewfinder, 'photo game viewfinder Task') self.accept('mouse1', self.__handleMouseClick) base.localAvatar.laffMeter.stop() base.transitions.noIris() def exitAim(self): self.__disableAimInterface() taskMgr.remove('photo game viewfinder Task') self.ignore('mouse1') def enterZoom(self): self.notify.debug('enterZoom') taskMgr.add(self.__moveViewfinder, 'photo game viewfinder Task') self.__doZoom() def exitZoom(self): taskMgr.remove('photo game viewfinder Task') self.notify.debug('exitZoom') def finishZoom(self, zoomed = None, task = None): if zoomed: self.captureLens.setFov(self.captureZoomFOV) else: self.captureLens.setFov(self.captureOutFOV) self.gameFSM.request('aim') def enterShowResults(self): self.notify.debug('enterShowResults') for subject in self.subjects: subject.resetLOD() def exitShowResults(self): pass def enterCleanup(self): self.notify.debug('enterCleanup') self.music.stop() if hasattr(self, 'jarIval'): self.jarIval.finish() del self.jarIval for avId in self.avIdList: taskMgr.remove('firePhoto' + str(avId)) taskMgr.remove('flyingToon' + str(avId)) def exitCleanup(self): pass def __enableAimInterface(self): 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.__spawnLocalPhotoMoveTask() def __disableAimInterface(self): 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.__killLocalPhotoMoveTask() 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.__leftReleased() def __rightKeyReleased(self): self.ignore(self.RIGHT_KEY + '-up') self.accept(self.RIGHT_KEY, self.__rightKeyPressed) 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.__downReleased() def __firePressed(self): self.notify.debug('fire pressed') def __fireReleased(self): self.gameFSM.request('zoom') 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 __handleMouseClick(self): self.notify.debug('mouse click') self.__testCollisions() def __enterControlActive(self, control): return control + 1 def __exitControlActive(self, control): return max(0, control - 1) def __spawnLocalPhotoMoveTask(self): self.leftPressed = 0 self.rightPressed = 0 self.upPressed = 0 self.downPressed = 0 self.photoMoving = 0 task = Task(self.__localPhotoMoveTask) task.lastPositionBroadcastTime = 0.0 taskMgr.add(task, self.LOCAL_PHOTO_MOVE_TASK) def __killLocalPhotoMoveTask(self): taskMgr.remove(self.LOCAL_PHOTO_MOVE_TASK) if self.photoMoving: self.sndPhotoMove.stop() def __localPhotoMoveTask(self, task): if not hasattr(self, 'swivel'): return pos = [self.swivel.getHpr()[0], self.swivel.getHpr()[1], self.swivel.getHpr()[2]] oldRot = pos[0] oldAng = pos[1] rotVel = 0 if self.leftPressed: rotVel += PhotoGameGlobals.PHOTO_ROTATION_VEL if self.rightPressed: rotVel -= PhotoGameGlobals.PHOTO_ROTATION_VEL pos[0] += rotVel * globalClock.getDt() angVel = 0 if self.upPressed: angVel += PhotoGameGlobals.PHOTO_ANGLE_VEL if self.downPressed: angVel -= PhotoGameGlobals.PHOTO_ANGLE_VEL pos[1] += angVel * globalClock.getDt() if pos[1] < PhotoGameGlobals.PHOTO_ANGLE_MIN: pos[1] = PhotoGameGlobals.PHOTO_ANGLE_MIN elif pos[1] > PhotoGameGlobals.PHOTO_ANGLE_MAX: pos[1] = PhotoGameGlobals.PHOTO_ANGLE_MAX if oldRot != pos[0] or oldAng != pos[1]: if self.photoMoving == 0: self.photoMoving = 1 base.playSfx(self.sndPhotoMove, looping=1) posVec = Vec3(pos[0], pos[1], pos[2]) self.swivel.setHpr(posVec) elif self.photoMoving: self.photoMoving = 0 self.sndPhotoMove.stop() return Task.cont def __putCameraOnTripod(self): camera.setPosHpr(0, 0.0, 0, 0, 0, 0) camera.reparentTo(self.swivel) self.swivel.setHpr(self.data['START_HPR']) def __loadToonInTripod(self, avId): toon = base.cr.doId2do.get(avId) if toon: toon.reparentTo(self.swivel) 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 __decreaseFilmCount(self): curTime = self.getCurrentGameTime() score = self.filmCount - 1 if not hasattr(self, 'curScore'): self.curScore = score self.filmPanel['text'] = str(score) if self.curScore != score: if hasattr(self, 'jarIval'): self.jarIval.finish() s = self.filmPanel.getScale() self.jarIval = Parallel(Sequence(self.filmPanel.scaleInterval(0.15, s * 3.0 / 4.0, blendType='easeOut'), self.filmPanel.scaleInterval(0.15, s, blendType='easeIn')), Sequence(Wait(0.25), SoundInterval(self.sndFilmTick)), name='photoGameFilmJarThrob') self.jarIval.start() self.curScore = score self.filmCount = score def __stopIntro(self): taskMgr.remove(self.INTRO_TASK_NAME) taskMgr.remove(self.INTRO_TASK_NAME_CAMERA_LERP) self.__putCameraOnTripod() if self.introSequence: self.introSequence.finish() self.introSequence = None return def __startIntro(self): camera.reparentTo(render) camera.setPos(self.data['CAMERA_INTIAL_POSTION']) camera.setHpr(0, 0, 0) camera.lookAt(self.tripod) lookatHpr = camera.getHpr() self.introSequence = LerpPosHprInterval(camera, 4.0, pos=self.tripod.getPos(render), hpr=lookatHpr, startPos=self.data['CAMERA_INTIAL_POSTION'], blendType='easeInOut') self.introSequence.start() def construct(self): zone = self.getSafezoneId() if zone == ToontownGlobals.ToontownCentral: self.constructTTC() elif zone == ToontownGlobals.DonaldsDock: self.constructDD() elif zone == ToontownGlobals.DaisyGardens: self.constructDG() elif zone == ToontownGlobals.MinniesMelodyland: self.constructMM() elif zone == ToontownGlobals.TheBrrrgh: self.constructBR() elif zone == ToontownGlobals.DonaldsDreamland: self.constructDL() def destruct(self): zone = self.getSafezoneId() if zone == ToontownGlobals.ToontownCentral: self.destructTTC() elif zone == ToontownGlobals.DonaldsDock: self.destructDD() elif zone == ToontownGlobals.DaisyGardens: self.destructDG() elif zone == ToontownGlobals.MinniesMelodyland: self.destructMM() elif zone == ToontownGlobals.TheBrrrgh: self.destructBR() elif zone == ToontownGlobals.DonaldsDreamland: self.destructDL() def constructTTC(self): self.photoRoot = self.scene.find('**/prop_gazebo*') self.sky = loader.loadModel('phase_3.5/models/props/TT_sky') self.sky.reparentTo(render) self.sky.setBin('background', -100) self.sky.find('**/cloud1').setBin('background', -99) self.sky.find('**/cloud2').setBin('background', -98) self.scene.reparentTo(render) self.makeDictionaries(self.dnaStore) self.createAnimatedProps(self.nodeList) self.startAnimatedProps() self.scene.find('**/door_trigger_22*').hide() self.scene.find('**/doorFrameHoleRight_0*').hide() self.scene.find('**/doorFrameHoleLeft_0*').hide() def destructTTC(self): self.stopAnimatedProps() self.deleteAnimatedProps() def constructDD(self): self.photoRoot = self.scene.find('**/center_island*') self.sky = loader.loadModel('phase_3.5/models/props/BR_sky') self.sky.reparentTo(render) self.sky.setBin('background', -100) self.sky.find('**/skypanel1').setBin('background', -98) self.sky.find('**/skypanel2').setBin('background', -97) self.sky.find('**/skypanel3').setBin('background', -96) self.sky.find('**/skypanel4').setBin('background', -95) self.sky.find('**/skypanel5').setBin('background', -94) self.sky.find('**/skypanel6').setBin('background', -93) self.scene.reparentTo(render) self.makeDictionaries(self.dnaStore) self.createAnimatedProps(self.nodeList) self.startAnimatedProps() boatGeom = self.scene.find('**/donalds_boat') self.photoRoot.setPos(-22, 0, 0) self.boat = self.photoRoot.attachNewNode('boat') boatGeom.reparentTo(self.boat) boatGeom.setX(45.0) boatGeom.setY(-5.0) boatGeom.setR(-0.0) boatGeom.setH(-8) self.bg = boatGeom self.boatTrack = Sequence() self.boatTrack.append(LerpHprInterval(self.boat, 90.0, Point3(360, 0, 0))) self.boatTrack.loop() self.boatTrack2 = Sequence() self.boatTrack2.append(LerpPosInterval(self.boat, 5.0, Point3(0, 0, 2.0), Point3(0, 0, 1.0), blendType='easeInOut')) self.boatTrack2.append(LerpPosInterval(self.boat, 5.0, Point3(0, 0, 1.0), Point3(0, 0, 2.0), blendType='easeInOut')) self.boatTrack2.loop() ddFog = Fog('DDFog Photo') ddFog.setColor(Vec4(0.8, 0.8, 0.8, 1.0)) ddFog.setLinearRange(0.0, 400.0) render.setFog(ddFog) water = self.scene.find('**/top_surface') water.setTransparency(TransparencyAttrib.MAlpha) water.setColorScale(1.0, 1.0, 1.0, 0.8) water.setDepthWrite(1) water.setDepthTest(1) water.setBin('transparent', 0) def destructDD(self): self.bg = None self.boatTrack.finish() self.boatTrack2.finish() self.boat.removeNode() render.clearFog() self.stopAnimatedProps() self.deleteAnimatedProps() return def constructDG(self): self.photoRoot = render.attachNewNode('DG PhotoRoot') self.photoRoot.setPos(1.39, 92.91, 2.0) self.bigFlower = loader.loadModel('phase_8/models/props/DG_flower-mod.bam') self.bigFlower.reparentTo(self.photoRoot) self.bigFlower.setScale(2.5) self.sky = loader.loadModel('phase_3.5/models/props/TT_sky') self.sky.reparentTo(render) self.sky.setBin('background', -100) self.sky.find('**/cloud1').setBin('background', -99) self.sky.find('**/cloud2').setBin('background', -98) self.scene.reparentTo(render) self.scene.find('**/door_trigger_5*').hide() self.scene.find('**/doorFrameHoleRight_0*').hide() self.scene.find('**/doorFrameHoleLeft_0*').hide() for name in ['**/o10_2']: maze = self.scene.find(name) maze.reparentTo(self.subjectNode) maze.setTag('sceneryIndex', '%s' % len(self.scenery)) self.scenery.append(maze) self.makeDictionaries(self.dnaStore) self.createAnimatedProps(self.nodeList) self.startAnimatedProps() def destructDG(self): self.bigFlower.removeNode() self.stopAnimatedProps() self.deleteAnimatedProps() def constructMM(self): self.photoRoot = render.attachNewNode('MM PhotoRoot') self.photoRoot.setPos(103.6, -61, -4.497) self.sky = loader.loadModel('phase_6/models/props/MM_sky') self.sky.reparentTo(render) self.sky.setBin('background', -100) self.scene.reparentTo(render) self.scene.find('**/door_trigger_8*').hide() self.scene.find('**/door_trigger_6*').hide() self.scene.find('**/door_trigger_1*').hide() self.scene.find('**/door_trigger_0*').hide() self.scene.find('**/door_trigger_3*').hide() self.scene.find('**/doorFrameHoleRight_0*').hide() self.scene.find('**/doorFrameHoleLeft_0*').hide() self.scene.find('**/doorFrameHoleRight_1*').hide() self.scene.find('**/doorFrameHoleLeft_1*').hide() self.scene.find('**/doorFrameHoleRight').hide() self.scene.find('**/doorFrameHoleLeft').hide() self.makeDictionaries(self.dnaStore) self.createAnimatedProps(self.nodeList) self.startAnimatedProps() lm = self.scene.findAllMatches('**/*landmark*') blocker = lm[2] blocker.reparentTo(self.subjectNode) blocker.setTag('sceneryIndex', '%s' % len(self.scenery)) self.scenery.append(blocker) def destructMM(self): self.stopAnimatedProps() self.deleteAnimatedProps() def constructBR(self): self.photoRoot = render.attachNewNode('BR PhotoRoot') self.photoRoot.setPos(-110, -48, 8.567) self.sky = loader.loadModel('phase_3.5/models/props/BR_sky') self.sky.reparentTo(render) self.sky.setBin('background', -100) self.scene.reparentTo(render) self.scene.find('**/door_trigger_11*').hide() self.scene.find('**/doorFrameHoleRight_0*').hide() self.scene.find('**/doorFrameHoleLeft_0*').hide() self.makeDictionaries(self.dnaStore) self.createAnimatedProps(self.nodeList) self.startAnimatedProps() self.snow = BattleParticles.loadParticleFile('snowdisk.ptf') self.snow.setPos(0, 0, 5) self.snowRender = self.scene.attachNewNode('snowRender') self.snowRender.setDepthWrite(0) self.snowRender.setBin('fixed', 1) self.snowFade = None self.snow.start(camera, self.snowRender) return def destructBR(self): self.snow.cleanup() del self.snow del self.snowRender self.stopAnimatedProps() self.deleteAnimatedProps() def constructDL(self): self.photoRoot = render.attachNewNode('DL PhotoRoot') self.photoRoot.setPos(-70.228, 87.588, 4.397) self.sky = loader.loadModel('phase_8/models/props/DL_sky') self.sky.reparentTo(render) self.sky.setBin('background', -100) self.scene.reparentTo(render) self.scene.find('**/door_trigger_8*').hide() self.scene.find('**/doorFrameHoleRight_0*').hide() self.scene.find('**/doorFrameHoleLeft_0*').hide() self.scene.find('**/doorFrameHoleRight_1*').hide() self.scene.find('**/doorFrameHoleLeft_1*').hide() self.makeDictionaries(self.dnaStore) self.createAnimatedProps(self.nodeList) self.startAnimatedProps() def destructDL(self): self.stopAnimatedProps() self.deleteAnimatedProps() def makeDictionaries(self, dnaStore): self.nodeList = [] for i in range(dnaStore.getNumDNAVisGroups()): groupFullName = dnaStore.getDNAVisGroupName(i) groupName = base.cr.hoodMgr.extractGroupName(groupFullName) groupNode = self.scene.find('**/' + groupFullName) if groupNode.isEmpty(): self.notify.error('Could not find visgroup') self.nodeList.append(groupNode) def startAnimatedProps(self): for animPropListKey in self.animPropDict: animPropList = self.animPropDict[animPropListKey] for animProp in animPropList: animProp.enter() def stopAnimatedProps(self): for animPropListKey in self.animPropDict: animPropList = self.animPropDict[animPropListKey] for animProp in animPropList: animProp.exit() def createAnimatedProps(self, nodeList): self.animPropDict = {} for i in nodeList: animPropNodes = i.findAllMatches('**/animated_prop_*') numAnimPropNodes = animPropNodes.getNumPaths() for j in range(numAnimPropNodes): animPropNode = animPropNodes.getPath(j) if animPropNode.getName().startswith('animated_prop_generic'): className = 'GenericAnimatedProp' else: className = animPropNode.getName()[14:-8] symbols = {} base.cr.importModule(symbols, 'toontown.hood', [className]) classObj = getattr(symbols[className], className) animPropObj = classObj(animPropNode) animPropList = self.animPropDict.setdefault(i, []) animPropList.append(animPropObj) interactivePropNodes = i.findAllMatches('**/interactive_prop_*') numInteractivePropNodes = interactivePropNodes.getNumPaths() for j in range(numInteractivePropNodes): interactivePropNode = interactivePropNodes.getPath(j) className = 'GenericAnimatedProp' symbols = {} base.cr.importModule(symbols, 'toontown.hood', [className]) classObj = getattr(symbols[className], className) interactivePropObj = classObj(interactivePropNode) animPropList = self.animPropDict.get(i) if animPropList is None: animPropList = self.animPropDict.setdefault(i, []) animPropList.append(interactivePropObj) return def deleteAnimatedProps(self): for animPropListKey in self.animPropDict: animPropList = self.animPropDict[animPropListKey] for animProp in animPropList: animProp.delete() del self.animPropDict def addSound(self, name, soundName, path = None): if not hasattr(self, 'soundTable'): self.soundTable = {} if path: self.soundPath = path soundSource = '%s%s' % (self.soundPath, soundName) self.soundTable[name] = loader.loadSfx(soundSource) def playSound(self, name, volume = 1.0): if hasattr(self, 'soundTable'): self.soundTable[name].setVolume(volume) self.soundTable[name].play()