class DistributedButterfly(DistributedObject.DistributedObject):
notify = DirectNotifyGlobal.directNotify.newCategory(
'DistributedButterfly')
id = 0
# wings_1 (solid yellow)
# wings_2 (yellow w/ dots) (1, 1, 1), (0.2, 0, 1), (1, 0, 1), (0.8, 0, 1)
# wings_3 (solid white) (0.8, 0, 0.8), (0, 0.8, 0.8), (0.9, 0.4, 0.6)
# (0.9, 0.4, 0.4), (0.8, 0.5, 0.9), (0.4, 0.1, 0.7)
# wings_4 (white w/ dots)
# wings_5 (pale yellow w/ lines) (0.8, 0, 0.8), (0.6, 0.6, 0.9)
# (0.7, 0.6, 0.9), (0.8, 0.6, 0.9), (0.9, 0.6, 0.9),
# (1, 0.6, 0.9)
# wings_6 (blue & yellow)
wingTypes = ('wings_1', 'wings_2', 'wings_3', 'wings_4', 'wings_5',
'wings_6')
yellowColors = (Vec4(1, 1, 1, 1), Vec4(0.2, 0, 1, 1), Vec4(0.8, 0, 1, 1))
whiteColors = (Vec4(0.8, 0, 0.8, 1), Vec4(0, 0.8, 0.8,
1), Vec4(0.9, 0.4, 0.6, 1),
Vec4(0.9, 0.4, 0.4, 1), Vec4(0.8, 0.5, 0.9,
1), Vec4(0.4, 0.1, 0.7, 1))
paleYellowColors = (Vec4(0.8, 0, 0.8, 1), Vec4(0.6, 0.6, 0.9,
1), Vec4(0.7, 0.6, 0.9, 1),
Vec4(0.8, 0.6, 0.9, 1), Vec4(0.9, 0.6, 0.9,
1), Vec4(1, 0.6, 0.9, 1))
shadowScaleBig = Point3(0.07, 0.07, 0.07)
shadowScaleSmall = Point3(0.01, 0.01, 0.01)
def __init__(self, cr):
"""__init__(cr)
"""
DistributedObject.DistributedObject.__init__(self, cr)
self.fsm = ClassicFSM.ClassicFSM(
'DistributedButterfly',
[
State.State('off', self.enterOff, self.exitOff,
['Flying', 'Landed']),
State.State('Flying', self.enterFlying, self.exitFlying,
['Landed']),
State.State('Landed', self.enterLanded, self.exitLanded,
['Flying'])
],
# Initial State
'off',
# Final State
'off',
)
self.butterfly = None
self.butterflyNode = None
self.curIndex = 0
self.destIndex = 0
self.time = 0.0
self.ival = None
self.fsm.enterInitialState()
def generate(self):
"""generate(self)
This method is called when the DistributedObject is reintroduced
to the world, either for the first time or from the cache.
"""
DistributedObject.DistributedObject.generate(self)
if self.butterfly:
return
self.butterfly = Actor.Actor()
self.butterfly.loadModel('phase_4/models/props/SZ_butterfly-mod.bam')
self.butterfly.loadAnims({
'flutter':
'phase_4/models/props/SZ_butterfly-flutter.bam',
'glide':
'phase_4/models/props/SZ_butterfly-glide.bam',
'land':
'phase_4/models/props/SZ_butterfly-land.bam'
})
# Randomly choose one of the butterfly wing patterns
index = self.doId % len(self.wingTypes)
chosenType = self.wingTypes[index]
node = self.butterfly.getGeomNode()
for type in self.wingTypes:
wing = node.find('**/' + type)
if (type != chosenType):
wing.removeNode()
else:
# Choose an appropriate blend color
if (index == 0 or index == 1):
color = self.yellowColors[self.doId %
len(self.yellowColors)]
elif (index == 2 or index == 3):
color = self.whiteColors[self.doId % len(self.whiteColors)]
elif (index == 4):
color = self.paleYellowColors[self.doId %
len(self.paleYellowColors)]
else:
color = Vec4(1, 1, 1, 1)
wing.setColor(color)
# Make another copy of the butterfly model so we can LOD the
# blending. Butterflies that are far away won't bother to
# blend animations; nearby butterflies will use dynamic
# blending to combine two or more animations at once on
# playback for a nice fluttering and landing effect.
self.butterfly2 = Actor.Actor(other=self.butterfly)
# Allow the nearby butterfly to blend between its three
# animations. All animations will be playing all the time;
# we'll control which one is visible by varying the control
# effect.
#self.butterfly.enableBlend(blendType = PartBundle.BTLinear)
#self.butterfly.loop('flutter', layer = 0)
#self.butterfly.loop('land', layer = 1)
#self.butterfly.loop('glide', layer = 2)
# Set up a pose parameter to blend between the butterfly animations.
#self.butterflyPoseParam = self.butterfly.addPoseParameter("butterfly", 0, 100)
# Now create the sequence that will blend between the animations using
# the pose parameter value.
#seq = AnimSequence("butterfly")
#seq.setNumFrames(50)
##seq.setFrameRate(24)
#seq.addLayer(self.butterfly.getAnim("land"), 0, 0, 1, 1, False, False, False, self.butterflyPoseParam)
#seq.addLayer(self.butterfly.getAnim("glide"), 1, 1, 50, 50, False, False, False, self.butterflyPoseParam)
#seq.addLayer(self.butterfly.getAnim("land"), 50, 50, 100, 100, False, False, False, self.butterflyPoseParam)
# Make a random play rate so all the butterflies will be
# flapping at slightly different rates. This doesn't affect
# the rate at which the butterfly moves, just the rate at
# which the animation plays on the butterfly.
rng = RandomNumGen.RandomNumGen(self.doId)
playRate = 0.6 + 0.8 * rng.random()
self.butterfly.setPlayRate(playRate, 'flutter')
self.butterfly.setPlayRate(playRate, 'land')
self.butterfly.setPlayRate(playRate, 'glide')
self.butterfly2.setPlayRate(playRate, 'flutter')
self.butterfly2.setPlayRate(playRate, 'land')
self.butterfly2.setPlayRate(playRate, 'glide')
# Also, a random glide contribution ratio. We'll blend a bit
# of the glide animation in with the flutter animation to
# dampen the effect of flutter. The larger the number here,
# the greater the dampening effect. Some butterflies will be
# more active than others. (Except when seen from a long way
# off, because of the LODNode, below.)
self.glideWeight = rng.random() * 2
lodNode = LODNode('butterfly-node')
lodNode.addSwitch(100, 40) # self.butterfly2
lodNode.addSwitch(40, 0) # self.butterfly
self.butterflyNode = NodePath(lodNode)
self.butterfly2.setH(180.0)
self.butterfly2.reparentTo(self.butterflyNode)
self.butterfly.setH(180.0)
self.butterfly.reparentTo(self.butterflyNode)
self.__initCollisions()
# Set up the drop shadow
if ShadowCaster.globalDropShadowFlag:
self.dropShadow = loader.loadModel(
'phase_3/models/props/drop_shadow')
else:
self.dropShadow = NodePath("dummy_drop_shadow")
self.dropShadow.setColor(0, 0, 0, 0.3)
self.dropShadow.setPos(0, 0.1, -0.05)
self.dropShadow.setScale(self.shadowScaleBig)
self.dropShadow.reparentTo(self.butterfly)
def disable(self):
"""disable(self)
This method is called when the DistributedObject is removed from
active duty and stored in a cache.
"""
self.butterflyNode.reparentTo(hidden)
if (self.ival != None):
self.ival.finish()
self.__ignoreAvatars()
DistributedObject.DistributedObject.disable(self)
def delete(self):
"""delete(self)
This method is called when the DistributedObject is permanently
removed from the world and deleted from the cache.
"""
self.butterfly.cleanup()
self.butterfly = None
self.butterfly2.cleanup()
self.butterfly2 = None
self.butterflyNode.removeNode()
self.__deleteCollisions()
self.ival = None
del self.fsm
DistributedObject.DistributedObject.delete(self)
def uniqueButterflyName(self, name):
DistributedButterfly.id += 1
return (name + '-%d' % DistributedButterfly.id)
def __detectAvatars(self):
self.accept('enter' + self.cSphereNode.getName(),
self.__handleCollisionSphereEnter)
def __ignoreAvatars(self):
self.ignore('enter' + self.cSphereNode.getName())
def __initCollisions(self):
self.cSphere = CollisionSphere(0., 1., 0., 3.)
self.cSphere.setTangible(0)
self.cSphereNode = CollisionNode(
self.uniqueButterflyName('cSphereNode'))
self.cSphereNode.addSolid(self.cSphere)
self.cSphereNodePath = self.butterflyNode.attachNewNode(
self.cSphereNode)
self.cSphereNodePath.hide()
self.cSphereNode.setCollideMask(ToontownGlobals.WallBitmask)
def __deleteCollisions(self):
del self.cSphere
del self.cSphereNode
self.cSphereNodePath.removeNode()
del self.cSphereNodePath
def __handleCollisionSphereEnter(self, collEntry):
""" Response for a toon walking up to this NPC
"""
assert (self.notify.debug("Entering collision sphere..."))
# Tell the server
self.sendUpdate('avatarEnter', [])
def setArea(self, playground, area):
self.playground = playground
self.area = area
def setState(self, stateIndex, curIndex, destIndex, time, timestamp):
self.curIndex = curIndex
self.destIndex = destIndex
self.time = time
self.fsm.request(ButterflyGlobals.states[stateIndex],
[globalClockDelta.localElapsedTime(timestamp)])
##### Off state #####
def enterOff(self, ts=0.0):
if (self.butterflyNode != None):
self.butterflyNode.reparentTo(hidden)
return None
def exitOff(self):
if (self.butterflyNode != None):
self.butterflyNode.reparentTo(render)
return None
##### Flying state #####
def enterFlying(self, ts):
self.__detectAvatars()
curPos = ButterflyGlobals.ButterflyPoints[self.playground][self.area][
self.curIndex]
destPos = ButterflyGlobals.ButterflyPoints[self.playground][self.area][
self.destIndex]
# We'll hit the ground if we go straight from curPos to destPos
flyHeight = max(
curPos[2],
destPos[2]) + ButterflyGlobals.BUTTERFLY_HEIGHT[self.playground]
curPosHigh = Point3(curPos[0], curPos[1], flyHeight)
destPosHigh = Point3(destPos[0], destPos[1], flyHeight)
if (ts <= self.time):
flyTime = self.time - (
ButterflyGlobals.BUTTERFLY_TAKEOFF[self.playground] +
ButterflyGlobals.BUTTERFLY_LANDING[self.playground])
self.butterflyNode.setPos(curPos)
self.dropShadow.show()
self.dropShadow.setScale(self.shadowScaleBig)
oldHpr = self.butterflyNode.getHpr()
self.butterflyNode.headsUp(destPos)
newHpr = self.butterflyNode.getHpr()
self.butterflyNode.setHpr(oldHpr)
takeoffShadowT = 0.2 * ButterflyGlobals.BUTTERFLY_TAKEOFF[
self.playground]
landShadowT = 0.2 * ButterflyGlobals.BUTTERFLY_LANDING[
self.playground]
self.butterfly2.loop('flutter')
self.butterfly.loop('flutter')
self.ival = Sequence(
Parallel(
LerpPosHprInterval(
self.butterflyNode,
ButterflyGlobals.BUTTERFLY_TAKEOFF[self.playground],
curPosHigh, newHpr),
#LerpAnimInterval(self.butterfly,
# ButterflyGlobals.BUTTERFLY_TAKEOFF[self.playground],
# 'land', 'flutter'),
#LerpAnimInterval(self.butterfly,
# ButterflyGlobals.BUTTERFLY_TAKEOFF[self.playground],
# None, 'glide',
# startWeight = 0, endWeight = self.glideWeight),
Sequence(
LerpScaleInterval(self.dropShadow,
takeoffShadowT,
self.shadowScaleSmall,
startScale=self.shadowScaleBig),
HideInterval(self.dropShadow)),
),
LerpPosInterval(self.butterflyNode, flyTime, destPosHigh),
Parallel(
LerpPosInterval(
self.butterflyNode,
ButterflyGlobals.BUTTERFLY_LANDING[self.playground],
destPos),
#LerpAnimInterval(self.butterfly,
# ButterflyGlobals.BUTTERFLY_LANDING[self.playground],
# 'flutter', 'land'),
#LerpAnimInterval(self.butterfly,
# ButterflyGlobals.BUTTERFLY_LANDING[self.playground],
# None, 'glide',
# startWeight = self.glideWeight, endWeight = 0),
Sequence(
Wait(ButterflyGlobals.BUTTERFLY_LANDING[
self.playground] - landShadowT),
ShowInterval(self.dropShadow),
LerpScaleInterval(self.dropShadow,
landShadowT,
self.shadowScaleBig,
startScale=self.shadowScaleSmall)),
),
name=self.uniqueName("Butterfly"))
self.ival.start(ts)
else:
self.ival = None
self.butterflyNode.setPos(destPos)
self.butterfly.loop('land')
#self.butterfly.setControlEffect('land', 1.0)
#self.butterfly.setControlEffect('flutter', 0.0)
#self.butterfly.setControlEffect('glide', 0.0)
self.butterfly2.loop('land')
return None
def exitFlying(self):
self.__ignoreAvatars()
if (self.ival != None):
self.ival.finish()
self.ival = None
return None
##### Landed state #####
def enterLanded(self, ts):
self.__detectAvatars()
curPos = ButterflyGlobals.ButterflyPoints[self.playground][self.area][
self.curIndex]
self.butterflyNode.setPos(curPos)
self.dropShadow.show()
self.dropShadow.setScale(self.shadowScaleBig)
self.butterfly.loop('land')
#self.butterfly.setControlEffect('land', 1.0)
#self.butterfly.setControlEffect('flutter', 0.0)
#self.butterfly.setControlEffect('glide', 0.0)
self.butterfly2.pose(
'land', random.randrange(self.butterfly2.getNumFrames('land')))
return None
def exitLanded(self):
self.__ignoreAvatars()
return None
class CogdoFlyingCameraManager:
def __init__(self, cam, parent, player, level):
self._toon = player.toon
self._camera = cam
self._parent = parent
self._player = player
self._level = level
self._enabled = False
def enable(self):
if self._enabled:
return
self._toon.detachCamera()
self._prevToonY = 0.0
levelBounds = self._level.getBounds()
l = Globals.Camera.LevelBoundsFactor
self._bounds = (
(levelBounds[0][0] * l[0], levelBounds[0][1] * l[0]),
(levelBounds[1][0] * l[1], levelBounds[1][1] * l[1]),
(levelBounds[2][0] * l[2], levelBounds[2][1] * l[2]),
)
self._lookAtZ = self._toon.getHeight(
) + Globals.Camera.LookAtToonHeightOffset
self._camParent = NodePath('CamParent')
self._camParent.reparentTo(self._parent)
self._camParent.setPos(self._toon, 0, 0, 0)
self._camParent.setHpr(180, Globals.Camera.Angle, 0)
self._camera.reparentTo(self._camParent)
self._camera.setPos(0, Globals.Camera.Distance, 0)
self._camera.lookAt(self._toon, 0, 0, self._lookAtZ)
self._cameraLookAtNP = NodePath('CameraLookAt')
self._cameraLookAtNP.reparentTo(self._camera.getParent())
self._cameraLookAtNP.setPosHpr(self._camera.getPos(),
self._camera.getHpr())
self._levelBounds = self._level.getBounds()
self._enabled = True
self._frozen = False
self._initCollisions()
def _initCollisions(self):
self._camCollRay = CollisionRay()
camCollNode = CollisionNode('CameraToonRay')
camCollNode.addSolid(self._camCollRay)
camCollNode.setFromCollideMask(OTPGlobals.WallBitmask
| OTPGlobals.CameraBitmask
| ToontownGlobals.FloorEventBitmask
| ToontownGlobals.CeilingBitmask)
camCollNode.setIntoCollideMask(0)
self._camCollNP = self._camera.attachNewNode(camCollNode)
self._camCollNP.show()
self._collOffset = Vec3(0, 0, 0.5)
self._collHandler = CollisionHandlerQueue()
self._collTrav = CollisionTraverser()
self._collTrav.addCollider(self._camCollNP, self._collHandler)
self._betweenCamAndToon = {}
self._transNP = NodePath('trans')
self._transNP.reparentTo(render)
self._transNP.setTransparency(True)
self._transNP.setAlphaScale(Globals.Camera.AlphaBetweenToon)
self._transNP.setBin('fixed', 10000)
def _destroyCollisions(self):
self._collTrav.removeCollider(self._camCollNP)
self._camCollNP.removeNode()
del self._camCollNP
del self._camCollRay
del self._collHandler
del self._collOffset
del self._betweenCamAndToon
self._transNP.removeNode()
del self._transNP
def freeze(self):
self._frozen = True
def unfreeze(self):
self._frozen = False
def disable(self):
if not self._enabled:
return
self._destroyCollisions()
self._camera.wrtReparentTo(render)
self._cameraLookAtNP.removeNode()
del self._cameraLookAtNP
self._camParent.removeNode()
del self._camParent
del self._prevToonY
del self._lookAtZ
del self._bounds
del self._frozen
self._enabled = False
def update(self, dt=0.0):
self._updateCam(dt)
self._updateCollisions()
def _updateCam(self, dt):
toonPos = self._toon.getPos()
camPos = self._camParent.getPos()
x = camPos[0]
z = camPos[2]
toonWorldX = self._toon.getX(render)
maxX = Globals.Camera.MaxSpinX
toonWorldX = clamp(toonWorldX, -1.0 * maxX, maxX)
spinAngle = Globals.Camera.MaxSpinAngle * toonWorldX * toonWorldX / (
maxX * maxX)
newH = 180.0 + spinAngle
self._camParent.setH(newH)
spinAngle = spinAngle * (pi / 180.0)
distBehindToon = Globals.Camera.SpinRadius * cos(spinAngle)
distToRightOfToon = Globals.Camera.SpinRadius * sin(spinAngle)
d = self._camParent.getX() - clamp(toonPos[0], *self._bounds[0])
if abs(d) > Globals.Camera.LeewayX:
if d > Globals.Camera.LeewayX:
x = toonPos[0] + Globals.Camera.LeewayX
else:
x = toonPos[0] - Globals.Camera.LeewayX
x = self._toon.getX(render) + distToRightOfToon
boundToonZ = min(toonPos[2], self._bounds[2][1])
d = z - boundToonZ
if d > Globals.Camera.MinLeewayZ:
if self._player.velocity[2] >= 0 and toonPos[
1] != self._prevToonY or self._player.velocity[2] > 0:
z = boundToonZ + d * INVERSE_E**(dt *
Globals.Camera.CatchUpRateZ)
elif d > Globals.Camera.MaxLeewayZ:
z = boundToonZ + Globals.Camera.MaxLeewayZ
elif d < -Globals.Camera.MinLeewayZ:
z = boundToonZ - Globals.Camera.MinLeewayZ
if self._frozen:
y = camPos[1]
else:
y = self._toon.getY(render) - distBehindToon
self._camParent.setPos(x, smooth(camPos[1], y), smooth(camPos[2], z))
if toonPos[2] < self._bounds[2][1]:
h = self._cameraLookAtNP.getH()
if d >= Globals.Camera.MinLeewayZ:
self._cameraLookAtNP.lookAt(self._toon, 0, 0, self._lookAtZ)
elif d <= -Globals.Camera.MinLeewayZ:
self._cameraLookAtNP.lookAt(self._camParent, 0, 0,
self._lookAtZ)
self._cameraLookAtNP.setHpr(h, self._cameraLookAtNP.getP(), 0)
self._camera.setHpr(
smooth(self._camera.getHpr(), self._cameraLookAtNP.getHpr()))
self._prevToonY = toonPos[1]
def _updateCollisions(self):
pos = self._toon.getPos(self._camera) + self._collOffset
self._camCollRay.setOrigin(pos)
direction = -Vec3(pos)
direction.normalize()
self._camCollRay.setDirection(direction)
self._collTrav.traverse(render)
nodesInBetween = {}
if self._collHandler.getNumEntries() > 0:
self._collHandler.sortEntries()
for entry in self._collHandler.getEntries():
name = entry.getIntoNode().getName()
if name.find('col_') >= 0:
np = entry.getIntoNodePath().getParent()
if np not in nodesInBetween:
nodesInBetween[np] = np.getParent()
for np in list(nodesInBetween.keys()):
if np in self._betweenCamAndToon:
del self._betweenCamAndToon[np]
else:
np.setTransparency(True)
np.wrtReparentTo(self._transNP)
if np.getName().find('lightFixture') >= 0:
np.find('**/*floor_mesh').hide()
elif np.getName().find('platform') >= 0:
np.find('**/*Floor').hide()
for np, parent in list(self._betweenCamAndToon.items()):
np.wrtReparentTo(parent)
np.setTransparency(False)
if np.getName().find('lightFixture') >= 0:
np.find('**/*floor_mesh').show()
elif np.getName().find('platform') >= 0:
np.find('**/*Floor').show()
self._betweenCamAndToon = nodesInBetween
class CogdoExecutiveSuiteIntro(CogdoGameMovie):
notify = DirectNotifyGlobal.directNotify.newCategory('CogdoExecutiveSuiteIntro')
introDuration = 7
cameraMoveDuration = 3
def __init__(self, shopOwner):
CogdoGameMovie.__init__(self)
self._shopOwner = shopOwner
self._lookAtCamTarget = False
self._camTarget = None
self._camHelperNode = None
self._toonDialogueSfx = None
self.toonHead = None
self.frame = None
return
def displayLine(self, text):
self.notify.debug('displayLine')
self._dialogueLabel.node().setText(text)
self.toonHead.reparentTo(aspect2d)
self._toonDialogueSfx.play()
self.toonHead.setClipPlane(self.clipPlane)
def makeSuit(self, suitType):
self.notify.debug('makeSuit()')
suit = Suit.Suit()
dna = SuitDNA.SuitDNA()
dna.newSuit(suitType)
suit.setStyle(dna)
suit.isDisguised = 1
suit.generateSuit()
suit.setScale(1, 1, 2)
suit.setPos(0, 0, -4.4)
suit.reparentTo(self.toonHead)
for part in suit.getHeadParts():
part.hide()
#suit.loop('neutral')
def load(self):
self.notify.debug('load()')
CogdoGameMovie.load(self)
backgroundGui = loader.loadModel('phase_5/models/cogdominium/tt_m_gui_csa_flyThru')
self.bg = backgroundGui.find('**/background')
self.chatBubble = backgroundGui.find('**/chatBubble')
self.chatBubble.setScale(6.5, 6.5, 7.3)
self.chatBubble.setPos(0.32, 0, -0.78)
self.bg.setScale(5.2)
self.bg.setPos(0.14, 0, -0.6667)
self.bg.reparentTo(aspect2d)
self.chatBubble.reparentTo(aspect2d)
self.frame = DirectFrame(geom=self.bg,
relief=None,
pos=(0.2, 0, -0.6667),
)
self.bg.wrtReparentTo(self.frame)
self.gameTitleText = DirectLabel(parent=self.frame,
text=TTLocalizer.CogdoExecutiveSuiteTitle,
scale=TTLocalizer.MRPgameTitleText * 0.8,
text_align=TextNode.ACenter,
text_font=getSignFont(),
text_fg=(1.0, 0.33, 0.33, 1.0),
pos=TTLocalizer.MRgameTitleTextPos,
relief=None,
)
self.chatBubble.wrtReparentTo(self.frame)
self.frame.hide()
backgroundGui.removeNode()
# Create the Resistance Toon
self.toonDNA = ToonDNA.ToonDNA()
self.toonDNA.newToonFromProperties('dss', 'ss', 'm', 'm', 2, 0, 2, 2, 1, 8, 1, 8, 1, 14)
self.toonHead = Toon.Toon()
self.toonHead.setDNA(self.toonDNA)
self.makeSuit('sc')
self.toonHead.getGeomNode().setDepthWrite(1)
self.toonHead.getGeomNode().setDepthTest(1)
self.toonHead.loop('neutral')
self.toonHead.setPosHprScale(-0.73, 0, -1.27, 180, 0, 0, 0.18, 0.18, 0.18)
self.toonHead.reparentTo(hidden)
self.toonHead.startBlink()
self.clipPlane = self.toonHead.attachNewNode(PlaneNode('clip'))
self.clipPlane.node().setPlane(Plane(0, 0, 1, 0))
self.clipPlane.setPos(0, 0, 2.45)
self._toonDialogueSfx = loader.loadSfx('phase_3.5/audio/dial/AV_dog_long.mp3')
self._camHelperNode = NodePath('CamHelperNode')
self._camHelperNode.reparentTo(render)
dialogue = TTLocalizer.CogdoExecutiveSuiteIntroMessage
def start():
self.frame.show()
base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 0)
def showShopOwner():
self._setCamTarget(self._shopOwner, -10, offset=Point3(0, 0, 5))
def end():
self._dialogueLabel.reparentTo(hidden)
self.toonHead.reparentTo(hidden)
self.frame.hide()
base.setCellsAvailable(base.bottomCells + base.leftCells + base.rightCells, 1)
self._stopUpdateTask()
self._ival = Sequence(Func(start),
Func(self.displayLine, dialogue),
Func(showShopOwner),
ParallelEndTogether(camera.posInterval(
self.cameraMoveDuration,
Point3(8, 0, 13),
blendType='easeInOut',
),
camera.hprInterval(0.5,
self._camHelperNode.getHpr(),
blendType='easeInOut'),
),
Wait(self.introDuration),
Func(end),
)
self._startUpdateTask()
return
def _setCamTarget(self, targetNP, distance, offset = Point3(0, 0, 0), angle = Point3(0, 0, 0)):
camera.wrtReparentTo(render)
self._camTarget = targetNP
self._camOffset = offset
self._camAngle = angle
self._camDistance = distance
self._camHelperNode.setPos(self._camTarget, self._camOffset)
self._camHelperNode.setHpr(self._camTarget, 180 + self._camAngle[0], self._camAngle[1], self._camAngle[2])
self._camHelperNode.setPos(self._camHelperNode, 0, self._camDistance, 0)
def _updateTask(self, task):
dt = globalClock.getDt()
return task.cont
def unload(self):
self._shopOwner = None
self._camTarget = None
if hasattr(self, '_camHelperNode') and self._camHelperNode:
self._camHelperNode.removeNode()
del self._camHelperNode
self.frame.destroy()
del self.frame
self.bg.removeNode()
del self.bg
self.chatBubble.removeNode()
del self.chatBubble
self.toonHead.stopBlink()
self.toonHead.stop()
self.toonHead.removeNode()
self.toonHead.delete()
del self.toonHead
CogdoGameMovie.unload(self)
return
