1662 lines
66 KiB
Python
1662 lines
66 KiB
Python
from direct.directnotify import DirectNotifyGlobal
|
|
from panda3d.core 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 panda3d.core 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()
|