def __init__(self):
try:
self.Avatar_initialized
except:
self.Avatar_initialized = 1
Actor.Actor.__init__(self)
self.__font = ToontownGlobals.getToonFont()
self.soundChatBubble = base.loadSfx(
'phase_3/audio/sfx/GUI_balloon_popup.mp3')
self.__nameVisible = 1
self.nametag = NametagGroup()
self.nametag.setAvatar(self)
self.nametag.setFont(ToontownGlobals.getInterfaceFont())
self.nametag2dContents = Nametag.CName | Nametag.CSpeech
self.nametag2dDist = Nametag.CName | Nametag.CSpeech
self.nametag3d = self.attachNewNode('nametag3d')
self.dropShadows = []
self.scale = 1.0
self.nametagScale = 1.0
self.height = 0.0
self.name = ''
self.style = None
self.commonChatFlags = 0
self.understandable = 1
self.setPlayerType(NametagGroup.CCNormal)
self.__chatParagraph = None
self.__chatMessage = None
self.__chatFlags = 0
self.__chatPageNumber = None
self.__chatAddressee = None
self.__chatSet = 0
self.__chatLocal = 0
return None
return
def buildFrame(self, name, dnaTuple):
frame = loader.loadModelCopy('phase_3.5/models/modules/trophy_frame')
dna = AvatarDNA.AvatarDNA()
apply(dna.newToonFromProperties, dnaTuple)
head = ToonHead.ToonHead()
head.setupHead(dna)
head.setPosHprScale(0, -0.05, -0.05, 180, 0, 0, 0.55, 0.02, 0.55)
if dna.head[0] == 'r':
head.setZ(-0.15)
else:
if dna.head[0] == 'h':
head.setZ(0.05)
else:
if dna.head[0] == 'm':
head.setScale(0.45, 0.02, 0.45)
head.reparentTo(frame)
nameText = TextNode('trophy')
nameText.setFont(ToontownGlobals.getToonFont())
nameText.setAlign(TextNode.ACenter)
nameText.setTextColor(0, 0, 0, 1)
nameText.setWordwrap(5.36 * FrameScale)
nameText.setText(name)
namePath = frame.attachNewNode(nameText.generate())
namePath.setPos(0, -0.03, -0.6)
namePath.setScale(0.186 / FrameScale)
frame.setScale(FrameScale, 1.0, FrameScale)
return frame
def buildFrame(self, name, dnaTuple):
frame = loader.loadModelCopy('phase_3.5/models/modules/trophy_frame')
dna = AvatarDNA.AvatarDNA()
apply(dna.newToonFromProperties, dnaTuple)
head = ToonHead.ToonHead()
head.setupHead(dna)
head.setPosHprScale(0, -0.050000000000000003, -0.050000000000000003, 180, 0, 0, 0.55000000000000004, 0.02, 0.55000000000000004)
if dna.head[0] == 'r':
head.setZ(-0.14999999999999999)
elif dna.head[0] == 'h':
head.setZ(0.050000000000000003)
elif dna.head[0] == 'm':
head.setScale(0.45000000000000001, 0.02, 0.45000000000000001)
head.reparentTo(frame)
nameText = TextNode('trophy')
nameText.setFont(ToontownGlobals.getToonFont())
nameText.setAlign(TextNode.ACenter)
nameText.setTextColor(0, 0, 0, 1)
nameText.setWordwrap(5.3600000000000003 * FrameScale)
nameText.setText(name)
namePath = frame.attachNewNode(nameText.generate())
namePath.setPos(0, -0.029999999999999999, -0.59999999999999998)
namePath.setScale(0.186 / FrameScale)
frame.setScale(FrameScale, 1.0, FrameScale)
return frame
def knockKnockTrack(self, avatar, duration):
if avatar == None:
return None
self.rimshot = base.loadSfx('phase_5/audio/sfx/AA_heal_telljoke.mp3')
self.knockSfx = base.loadSfx('phase_5/audio/sfx/GUI_knock_3.mp3')
joke = KnockKnockJokes[self.propId % len(KnockKnockJokes)]
self.nametag = None
self.nametagNP = None
doorNP = render.find('**/KnockKnockDoorSphere_' + str(self.propId) + ';+s')
if doorNP.isEmpty():
self.notify.warning('Could not find KnockKnockDoorSphere_%s' % self.propId)
return None
self.nametag = NametagGroup()
self.nametag.setAvatar(doorNP)
self.nametag.setFont(ToontownGlobals.getToonFont())
self.nametag.setName('door')
self.nametag.setActive(0)
self.nametag.manage(toonbase.marginManager)
self.nametag.getNametag3d().setBillboardOffset(4)
nametagNode = self.nametag.getNametag3d().upcastToPandaNode()
self.nametagNP = render.attachNewNode(nametagNode)
self.nametagNP.setName('knockKnockDoor_nt_' + str(self.propId))
pos = doorNP.node().getSolid(0).getCenter()
self.nametagNP.setPos(pos + Vec3(0, 0, avatar.getHeight() + 2))
d = duration * 0.125
track = Sequence(Parallel(Sequence(Wait(d * 0.5), SoundInterval(self.knockSfx)), Func(self.nametag.setChat, Localizer.DoorKnockKnock, CFSpeech), Wait(d)), Func(avatar.setChatAbsolute, Localizer.DoorWhosThere, CFSpeech | CFTimeout, openEnded = 0), Wait(d), Func(self.nametag.setChat, joke[0], CFSpeech), Wait(d), Func(avatar.setChatAbsolute, joke[0] + Localizer.DoorWhoAppendix, CFSpeech | CFTimeout, openEnded = 0), Wait(d), Func(self.nametag.setChat, joke[1], CFSpeech), Parallel(SoundInterval(self.rimshot, startTime = 2.0), Wait(d * 4)), Func(self.cleanupTrack))
track.delayDelete = DelayDelete.DelayDelete(avatar)
return track
def __init__(self):
try:
pass
except:
self.Avatar_initialized = 1
Actor.Actor.__init__(self)
self._Avatar__font = ToontownGlobals.getToonFont()
self.soundChatBubble = base.loadSfx('phase_3/audio/sfx/GUI_balloon_popup.mp3')
self._Avatar__nameVisible = 1
self.nametag = NametagGroup()
self.nametag.setAvatar(self)
self.nametag.setFont(ToontownGlobals.getInterfaceFont())
self.nametag2dContents = Nametag.CName | Nametag.CSpeech
self.nametag2dDist = Nametag.CName | Nametag.CSpeech
self.nametag3d = self.attachNewNode('nametag3d')
self.dropShadows = []
self.scale = 1.0
self.nametagScale = 1.0
self.height = 0.0
self.name = ''
self.style = None
self.commonChatFlags = 0
self.understandable = 1
self.setPlayerType(NametagGroup.CCNormal)
self._Avatar__chatParagraph = None
self._Avatar__chatMessage = None
self._Avatar__chatFlags = 0
self._Avatar__chatPageNumber = None
self._Avatar__chatAddressee = None
self._Avatar__chatSet = 0
self._Avatar__chatLocal = 0
return None
def knockKnockTrack(self, avatar, duration):
if avatar == None:
return None
self.rimshot = base.loadSfx('phase_5/audio/sfx/AA_heal_telljoke.mp3')
self.knockSfx = base.loadSfx('phase_5/audio/sfx/GUI_knock_3.mp3')
joke = KnockKnockJokes[self.propId % len(KnockKnockJokes)]
self.nametag = None
self.nametagNP = None
doorNP = render.find('**/KnockKnockDoorSphere_' + str(self.propId) +
';+s')
if doorNP.isEmpty():
self.notify.warning('Could not find KnockKnockDoorSphere_%s' %
self.propId)
return None
self.nametag = NametagGroup()
self.nametag.setAvatar(doorNP)
self.nametag.setFont(ToontownGlobals.getToonFont())
self.nametag.setName('door')
self.nametag.setActive(0)
self.nametag.manage(toonbase.marginManager)
self.nametag.getNametag3d().setBillboardOffset(4)
nametagNode = self.nametag.getNametag3d().upcastToPandaNode()
self.nametagNP = render.attachNewNode(nametagNode)
self.nametagNP.setName('knockKnockDoor_nt_' + str(self.propId))
pos = doorNP.node().getSolid(0).getCenter()
self.nametagNP.setPos(pos + Vec3(0, 0, avatar.getHeight() + 2))
d = duration * 0.125
track = Sequence(
Parallel(
Sequence(Wait(d * 0.5), SoundInterval(self.knockSfx)),
Func(self.nametag.setChat, Localizer.DoorKnockKnock, CFSpeech),
Wait(d)),
Func(avatar.setChatAbsolute,
Localizer.DoorWhosThere,
CFSpeech | CFTimeout,
openEnded=0), Wait(d),
Func(self.nametag.setChat, joke[0], CFSpeech), Wait(d),
Func(avatar.setChatAbsolute,
joke[0] + Localizer.DoorWhoAppendix,
CFSpeech | CFTimeout,
openEnded=0), Wait(d),
Func(self.nametag.setChat, joke[1], CFSpeech),
Parallel(SoundInterval(self.rimshot, startTime=2.0), Wait(d * 4)),
Func(self.cleanupTrack))
track.delayDelete = DelayDelete.DelayDelete(avatar)
return track
def showfont(self, fontname):
fontname = string.strip(string.lower(fontname))
if fontname == '' or fontname == 'interface':
font = ToontownGlobals.getInterfaceFont()
else:
if fontname == 'toon':
font = ToontownGlobals.getToonFont()
else:
if fontname == 'suit':
font = ToontownGlobals.getSuitFont()
else:
if fontname == 'sign':
font = ToontownGlobals.getSignFont()
else:
self.setMagicWordResponse('Unknown font: %s' % fontname)
return
if not isinstance(font, DynamicTextFont):
self.setMagicWordResponse('Font %s is not dynamic.' % fontname)
return
self.hidefont()
self.shownFontNode = aspect2d.attachNewNode('shownFont')
tn = TextNode('square')
tn.freeze()
tn.setCardActual(0.0, 1.0, -1.0, 0.0)
tn.setFrameActual(0.0, 1.0, -1.0, 0.0)
tn.setCardColor(1, 1, 1, 0.5)
tn.setFrameColor(1, 1, 1, 1)
tn.setFont(font)
tn.setText(' ')
numXPages = 2
numYPages = 2
pageScale = 0.8
pageMargin = 0.1
numPages = font.getNumPages()
x = 0
y = 0
for pi in range(numPages):
page = font.getPage(pi)
tn.setCardTexture(page)
np = self.shownFontNode.attachNewNode(tn.generate())
np.setScale(pageScale)
(
np.setPos(float(x) / numXPages * 2 - 1 + pageMargin, 0, 1 - float(y) / numYPages * 2 - pageMargin),)
x += 1
if x >= numXPages:
y += 1
def showfont(self, fontname):
fontname = string.strip(string.lower(fontname))
if fontname == '' or fontname == 'interface':
font = ToontownGlobals.getInterfaceFont()
elif fontname == 'toon':
font = ToontownGlobals.getToonFont()
elif fontname == 'suit':
font = ToontownGlobals.getSuitFont()
elif fontname == 'sign':
font = ToontownGlobals.getSignFont()
else:
self.setMagicWordResponse('Unknown font: %s' % fontname)
return None
if not isinstance(font, DynamicTextFont):
self.setMagicWordResponse('Font %s is not dynamic.' % fontname)
return None
self.hidefont()
self.shownFontNode = aspect2d.attachNewNode('shownFont')
tn = TextNode('square')
tn.freeze()
tn.setCardActual(0.0, 1.0, -1.0, 0.0)
tn.setFrameActual(0.0, 1.0, -1.0, 0.0)
tn.setCardColor(1, 1, 1, 0.5)
tn.setFrameColor(1, 1, 1, 1)
tn.setFont(font)
tn.setText(' ')
numXPages = 2
numYPages = 2
pageScale = 0.80000000000000004
pageMargin = 0.10000000000000001
numPages = font.getNumPages()
x = 0
y = 0
for pi in range(numPages):
page = font.getPage(pi)
tn.setCardTexture(page)
np = self.shownFontNode.attachNewNode(tn.generate())
np.setScale(pageScale)
(np.setPos(((float(x) / numXPages) * 2 - 1) + pageMargin, 0,
1 - (float(y) / numYPages) * 2 - pageMargin), )
x += 1
if x >= numXPages:
y += 1
def getFont(self):
return ToontownGlobals.getToonFont()
class DistributedCannonGame(DistributedMinigame):
font = ToontownGlobals.getToonFont()
LOCAL_CANNON_MOVE_TASK = 'localCannonMoveTask'
REWARD_COUNTDOWN_TASK = 'cannonGameRewardCountdown'
HIT_GROUND = 0
HIT_TOWER = 1
HIT_WATER = 2
FIRE_KEY = 'control'
UP_KEY = 'arrow_up'
DOWN_KEY = 'arrow_down'
LEFT_KEY = 'arrow_left'
RIGHT_KEY = 'arrow_right'
INTRO_TASK_NAME = 'CannonGameIntro'
INTRO_TASK_NAME_CAMERA_LERP = 'CannonGameIntroCamera'
def __init__(self, cr):
DistributedMinigame.__init__(self, cr)
self.gameFSM = FSM.FSM('DistributedCannonGame', [
State.State('off', self.enterOff, self.exitOff, [
'aim']),
State.State('aim', self.enterAim, self.exitAim, [
'shoot',
'waitForToonsToLand',
'cleanup']),
State.State('shoot', self.enterShoot, self.exitShoot, [
'aim',
'waitForToonsToLand',
'cleanup']),
State.State('waitForToonsToLand', self.enterWaitForToonsToLand, self.exitWaitForToonsToLand, [
'cleanup']),
State.State('cleanup', self.enterCleanup, self.exitCleanup, [])], 'off', 'cleanup')
self.addChildGameFSM(self.gameFSM)
self.cannonLocationDict = { }
self.cannonPositionDict = { }
self.cannonDict = { }
self.toonModelDict = { }
self.dropShadowDict = { }
self.toonHeadDict = { }
self.toonScaleDict = { }
self.toonIntervalDict = { }
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.cannonMoving = 0
self.modelCount = 14
def getTitle(self):
return Localizer.CannonGameTitle
def getInstructions(self):
return Localizer.CannonGameInstructions
def getMaxDuration(self):
return CannonGameGlobals.GameTime
def load(self):
self.notify.debug('load')
DistributedMinigame.load(self)
self.sky = loader.loadModel('phase_3.5/models/props/TT_sky')
self.ground = loader.loadModel('phase_4/models/minigames/toon_cannon_gameground')
self.tower = loader.loadModel('phase_4/models/minigames/toon_cannon_water_tower')
self.cannon = loader.loadModel('phase_4/models/minigames/toon_cannon')
self.dropShadow = loader.loadModel('phase_3/models/props/drop_shadow')
self.hill = loader.loadModel('phase_4/models/minigames/cannon_hill')
self.sky.setScale(WORLD_SCALE)
self.ground.setScale(GROUND_SCALE)
self.cannon.setScale(CANNON_SCALE)
self.dropShadow.setColor(0, 0, 0, 0.5)
self.ground.setColor(0.84999999999999998, 0.84999999999999998, 0.84999999999999998, 1.0)
self.hill.setScale(1, 1, CANNON_Z / 20.0)
self.dropShadow.setBin('fixed', 0, 1)
self.splash = Splash.Splash(render)
self.dustCloud = DustCloud.DustCloud(render)
purchaseModels = loader.loadModel('phase_4/models/gui/purchase_gui')
self.jarImage = purchaseModels.find('**/Jar')
self.jarImage.reparentTo(hidden)
self.rewardPanel = DirectLabel(parent = hidden, relief = None, pos = (1.1599999999999999, 0.0, 0.45000000000000001), scale = 0.65000000000000002, text = '', text_scale = 0.20000000000000001, text_fg = (0.94999999999999996, 0.94999999999999996, 0, 1), text_pos = (0, -0.13), text_font = ToontownGlobals.getSignFont(), image = self.jarImage)
self.rewardPanelTitle = DirectLabel(parent = self.rewardPanel, relief = None, pos = (0, 0, 0.059999999999999998), scale = 0.080000000000000002, text = Localizer.CannonGameReward, text_fg = (0.94999999999999996, 0.94999999999999996, 0, 1), text_shadow = (0, 0, 0, 1))
self.music = base.loadMusic('phase_4/audio/bgm/MG_cannon_game.mid')
self.sndCannonMove = base.loadSfx('phase_4/audio/sfx/MG_cannon_adjust.mp3')
self.sndCannonFire = base.loadSfx('phase_4/audio/sfx/MG_cannon_fire_alt.mp3')
self.sndHitGround = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_dirt.mp3')
self.sndHitTower = base.loadSfx('phase_4/audio/sfx/MG_cannon_hit_tower.mp3')
self.sndHitWater = base.loadSfx('phase_4/audio/sfx/MG_cannon_splash.mp3')
self.sndWhizz = base.loadSfx('phase_4/audio/sfx/MG_cannon_whizz.mp3')
self.sndWin = base.loadSfx('phase_4/audio/sfx/MG_win.mp3')
self.sndRewardTick = base.loadSfx('phase_3.5/audio/sfx/tick_counter.mp3')
guiModel = 'phase_4/models/gui/cannon_game_gui'
cannonGui = loader.loadModel(guiModel)
self.aimPad = DirectFrame(image = cannonGui.find('**/CannonFire_PAD'), relief = None, pos = (0.69999999999999996, 0, -0.55333299999999996), scale = 0.80000000000000004)
cannonGui.removeNode()
self.aimPad.hide()
self.fireButton = DirectButton(parent = self.aimPad, image = ((guiModel, '**/Fire_Btn_UP'), (guiModel, '**/Fire_Btn_DN'), (guiModel, '**/Fire_Btn_RLVR')), relief = None, pos = (0.0115741, 0, 0.0050505100000000002), scale = 1.0, command = self._DistributedCannonGame__firePressed)
self.upButton = DirectButton(parent = self.aimPad, image = ((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief = None, pos = (0.0115741, 0, 0.221717))
self.downButton = DirectButton(parent = self.aimPad, image = ((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief = None, pos = (0.0136112, 0, -0.21010100000000001), image_hpr = (0, 0, 180))
self.leftButton = DirectButton(parent = self.aimPad, image = ((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief = None, pos = (-0.199352, 0, -0.00050526900000000003), image_hpr = (0, 0, 90))
self.rightButton = DirectButton(parent = self.aimPad, image = ((guiModel, '**/Cannon_Arrow_UP'), (guiModel, '**/Cannon_Arrow_DN'), (guiModel, '**/Cannon_Arrow_RLVR')), relief = None, pos = (0.219167, 0, -0.0010102399999999999), image_hpr = (0, 0, -90))
self.aimPad.setColor(1, 1, 1, 0.90000000000000002)
def bindButton(button, upHandler, downHandler):
button.bind(B1PRESS, lambda x, handler = upHandler: handler())
button.bind(B1RELEASE, lambda x, handler = downHandler: handler())
bindButton(self.upButton, self._DistributedCannonGame__upPressed, self._DistributedCannonGame__upReleased)
bindButton(self.downButton, self._DistributedCannonGame__downPressed, self._DistributedCannonGame__downReleased)
bindButton(self.leftButton, self._DistributedCannonGame__leftPressed, self._DistributedCannonGame__leftReleased)
bindButton(self.rightButton, self._DistributedCannonGame__rightPressed, self._DistributedCannonGame__rightReleased)
self.timer = ToontownTimer.ToontownTimer()
self.timer.posInTopRightCorner()
self.timer.hide()
self.DEBUG_TOWER_RANGE = 0
self.DEBUG_CANNON_FAR_LEFT = 0
self.DEBUG_TOWER_NEAR = 1
self.DEBUG_TOWER_FAR_LEFT = 1
self.cheat = config.GetBool('cannon-game-cheat', 0)
def unload(self):
self.notify.debug('unload')
DistributedMinigame.unload(self)
self.sky.removeNode()
del self.sky
self.ground.removeNode()
del self.ground
self.tower.removeNode()
del self.tower
self.cannon.removeNode()
del self.cannon
del self.dropShadowDict
self.dropShadow.removeNode()
del self.dropShadow
self.splash.destroy()
del self.splash
self.dustCloud.destroy()
del self.dustCloud
self.hill.removeNode()
del self.hill
self.rewardPanel.destroy()
del self.rewardPanel
self.jarImage.removeNode()
del self.jarImage
del self.music
del self.sndCannonMove
del self.sndCannonFire
del self.sndHitGround
del self.sndHitTower
del self.sndHitWater
del self.sndWhizz
del self.sndWin
del self.sndRewardTick
self.aimPad.destroy()
del self.aimPad
del self.fireButton
del self.upButton
del self.downButton
del self.leftButton
del self.rightButton
for avId in self.toonHeadDict.keys():
head = self.toonHeadDict[avId]
head.stopBlink()
head.stopLookAroundNow()
av = self.getAvatar(avId)
if av:
av.loop('neutral')
av.setPlayRate('run', 1.0)
av.nametag.removeNametag(head.tag)
head.delete()
del self.toonHeadDict
for model in self.toonModelDict.values():
model.removeNode()
del self.toonModelDict
del self.toonScaleDict
for interval in self.toonIntervalDict.values():
interval.stop()
del self.toonIntervalDict
for avId in self.avIdList:
self.cannonDict[avId][0].removeNode()
del self.cannonDict[avId][0]
del self.cannonDict
self.timer.destroy()
del self.timer
del self.cannonLocationDict
self.removeChildGameFSM(self.gameFSM)
del self.gameFSM
def onstage(self):
self.notify.debug('onstage')
DistributedMinigame.onstage(self)
self._DistributedCannonGame__createCannons()
for avId in self.avIdList:
self.cannonDict[avId][0].reparentTo(render)
self.towerPos = self.getTowerPosition()
self.tower.setPos(self.towerPos)
self.tower.reparentTo(render)
self.sky.reparentTo(render)
self.ground.reparentTo(render)
self.hill.setPosHpr(0, CANNON_Y + 2.3300000000000001, 0, 0, 0, 0)
self.hill.reparentTo(render)
self.splash.reparentTo(render)
self.dustCloud.reparentTo(render)
self._DistributedCannonGame__createToonModels(self.localAvId)
camera.reparentTo(render)
self._DistributedCannonGame__oldCamFar = base.camLens.getFar()
base.camLens.setFar(FAR_PLANE_DIST)
self._DistributedCannonGame__startIntro()
base.transitions.irisIn(0.40000000000000002)
base.playMusic(self.music, looping = 1, volume = 0.80000000000000004)
def offstage(self):
self.notify.debug('offstage')
self.sky.reparentTo(hidden)
self.ground.reparentTo(hidden)
self.hill.reparentTo(hidden)
self.tower.reparentTo(hidden)
for avId in self.avIdList:
self.cannonDict[avId][0].reparentTo(hidden)
if self.dropShadowDict.has_key(avId):
self.dropShadowDict[avId].reparentTo(hidden)
av = self.getAvatar(avId)
if av:
for dropShadow in av.dropShadows:
dropShadow.show()
av.resetLOD()
self.splash.reparentTo(hidden)
self.splash.stop()
self.dustCloud.reparentTo(hidden)
self.dustCloud.stop()
self._DistributedCannonGame__stopIntro()
base.camLens.setFar(self._DistributedCannonGame__oldCamFar)
self.timer.reparentTo(hidden)
self.rewardPanel.reparentTo(hidden)
DistributedMinigame.offstage(self)
def getTowerPosition(self):
yRange = TOWER_Y_RANGE
yMin = yRange * 0.29999999999999999
yMax = yRange
if self.DEBUG_TOWER_RANGE:
if self.DEBUG_TOWER_NEAR:
y = yMin
else:
y = yMax
else:
y = self.randomNumGen.randint(yMin, yMax)
xRange = TOWER_X_RANGE
if self.DEBUG_TOWER_RANGE:
if self.DEBUG_TOWER_FAR_LEFT:
x = 0
else:
x = xRange
else:
x = self.randomNumGen.randint(0, xRange)
x = x - int(xRange / 2.0)
if toonbase.wantMinigameDifficulty:
diff = self.getDifficulty()
scale = 0.5 + 0.5 * diff
x *= scale
yCenter = (yMin + yMax) / 2.0
y = (y - yCenter) * scale + yCenter
x = float(x) * (float(y) / float(yRange))
y = y - int(yRange / 2.0)
self.notify.debug('getTowerPosition: ' + str(x) + ', ' + str(y))
return Point3(x, y, 0.0)
def _DistributedCannonGame__createCannons(self):
for avId in self.avIdList:
cannon = self.cannon.copyTo(hidden)
barrel = cannon.find('**/cannon')
self.cannonDict[avId] = [
cannon,
barrel]
numAvs = self.numPlayers
for i in range(numAvs):
avId = self.avIdList[i]
self.cannonLocationDict[avId] = Point3(i * CANNON_X_SPACING - (numAvs - 1) * CANNON_X_SPACING / 2, CANNON_Y, CANNON_Z)
if self.DEBUG_TOWER_RANGE:
if self.DEBUG_CANNON_FAR_LEFT:
self.cannonLocationDict[avId] = Point3(0 * CANNON_X_SPACING - (4 - 1) * CANNON_X_SPACING / 2, CANNON_Y, CANNON_Z)
else:
self.cannonLocationDict[avId] = Point3(3 * CANNON_X_SPACING - (4 - 1) * CANNON_X_SPACING / 2, CANNON_Y, CANNON_Z)
self.cannonPositionDict[avId] = [
0,
CANNON_ANGLE_MIN]
self.cannonDict[avId][0].setPos(self.cannonLocationDict[avId])
self._DistributedCannonGame__updateCannonPosition(avId)
def setGameReady(self):
self.notify.debug('setGameReady')
if DistributedMinigame.setGameReady(self):
return None
for avId in self.avIdList:
if avId != self.localAvId:
self._DistributedCannonGame__createToonModels(avId)
def _DistributedCannonGame__createToonModels(self, avId):
toon = self.getAvatar(avId)
self.toonScaleDict[avId] = toon.getScale()
toon.useLOD(1000)
toonParent = render.attachNewNode('toonOriginChange')
toon.reparentTo(toonParent)
toon.setPosHpr(0, 0, -(toon.getHeight() / 2.0), 0, 0, 0)
self.toonModelDict[avId] = toonParent
head = ToonHead.ToonHead()
head.setupHead(self.getAvatar(avId).style)
head.reparentTo(hidden)
self.toonHeadDict[avId] = head
toon = self.getAvatar(avId)
tag = NametagFloat3d()
tag.setContents(Nametag.CSpeech | Nametag.CThought)
tag.setBillboardOffset(0)
tag.setAvatar(head)
toon.nametag.addNametag(tag)
tagPath = head.attachNewNode(tag.upcastToPandaNode())
tagPath.setPos(0, 0, 1)
head.tag = tag
self._DistributedCannonGame__loadToonInCannon(avId)
for dropShadow in self.getAvatar(avId).dropShadows:
dropShadow.hide()
self.dropShadowDict[avId] = self.dropShadow.copyTo(hidden)
def setGameStart(self, timestamp):
self.notify.debug('setGameStart')
DistributedMinigame.setGameStart(self, timestamp)
self._DistributedCannonGame__stopIntro()
self._DistributedCannonGame__putCameraBehindCannon()
if not base.config.GetBool('endless-cannon-game', 0):
self.timer.show()
self.timer.countdown(CannonGameGlobals.GameTime, self._DistributedCannonGame__gameTimerExpired)
self.rewardPanel.reparentTo(aspect2d)
self._DistributedCannonGame__startRewardCountdown()
self.airborneToons = 0
self.clockStopTime = None
self.gameFSM.request('aim')
def _DistributedCannonGame__gameTimerExpired(self):
self.notify.debug('game timer expired')
self.gameOver()
def _DistributedCannonGame__playing(self):
return self.gameFSM.getCurrentState() != self.gameFSM.getFinalState()
def updateCannonPosition(self, avId, zRot, angle):
if not self._DistributedCannonGame__playing():
return None
if avId != self.localAvId:
self.cannonPositionDict[avId] = [
zRot,
angle]
self._DistributedCannonGame__updateCannonPosition(avId)
def setCannonWillFire(self, avId, fireTime, zRot, angle):
if not self._DistributedCannonGame__playing():
return None
self.notify.debug('setCannonWillFire: ' + str(avId) + ': zRot=' + str(zRot) + ', angle=' + str(angle) + ', time=' + str(fireTime))
self.cannonPositionDict[avId][0] = zRot
self.cannonPositionDict[avId][1] = angle
self._DistributedCannonGame__updateCannonPosition(avId)
task = Task.Task(self._DistributedCannonGame__fireCannonTask)
task.avId = avId
task.fireTime = fireTime
timeToWait = task.fireTime - self.getCurrentGameTime()
if timeToWait > 0.0:
fireTask = Task.sequence(Task.pause(timeToWait), task)
else:
fireTask = task
fireTask = task
taskMgr.add(fireTask, 'fireCannon' + str(avId))
self.airborneToons += 1
def announceToonWillLandInWater(self, avId, landTime):
self.notify.debug('announceToonWillLandInWater: ' + str(avId) + ': time=' + str(landTime))
if self.clockStopTime == None:
self.clockStopTime = landTime
def enterOff(self):
self.notify.debug('enterOff')
def exitOff(self):
pass
def enterAim(self):
self.notify.debug('enterAim')
self._DistributedCannonGame__enableAimInterface()
self._DistributedCannonGame__putCameraBehindCannon()
def exitAim(self):
self._DistributedCannonGame__disableAimInterface()
def enterShoot(self):
self.notify.debug('enterShoot')
self._DistributedCannonGame__broadcastLocalCannonPosition()
self.sendUpdate('setCannonLit', [
self.cannonPositionDict[self.localAvId][0],
self.cannonPositionDict[self.localAvId][1]])
def exitShoot(self):
pass
def _DistributedCannonGame__somebodyWon(self, avId):
if avId == self.localAvId:
base.playSfx(self.sndWin)
self._DistributedCannonGame__killRewardCountdown()
self.timer.stop()
self.gameFSM.request('waitForToonsToLand')
def enterWaitForToonsToLand(self):
self.notify.debug('enterWaitForToonsToLand')
if not (self.airborneToons):
self.gameOver()
def exitWaitForToonsToLand(self):
pass
def enterCleanup(self):
self.notify.debug('enterCleanup')
self.music.stop()
self._DistributedCannonGame__killRewardCountdown()
if hasattr(self, 'jarIval'):
self.jarIval.finish()
del self.jarIval
for avId in self.avIdList:
taskMgr.remove('fireCannon' + str(avId))
taskMgr.remove('flyingToon' + str(avId))
def exitCleanup(self):
pass
def _DistributedCannonGame__enableAimInterface(self):
self.aimPad.show()
self.accept(self.FIRE_KEY, self._DistributedCannonGame__fireKeyPressed)
self.accept(self.UP_KEY, self._DistributedCannonGame__upKeyPressed)
self.accept(self.DOWN_KEY, self._DistributedCannonGame__downKeyPressed)
self.accept(self.LEFT_KEY, self._DistributedCannonGame__leftKeyPressed)
self.accept(self.RIGHT_KEY, self._DistributedCannonGame__rightKeyPressed)
self._DistributedCannonGame__spawnLocalCannonMoveTask()
def _DistributedCannonGame__disableAimInterface(self):
self.aimPad.hide()
self.ignore(self.FIRE_KEY)
self.ignore(self.UP_KEY)
self.ignore(self.DOWN_KEY)
self.ignore(self.LEFT_KEY)
self.ignore(self.RIGHT_KEY)
self.ignore(self.FIRE_KEY + '-up')
self.ignore(self.UP_KEY + '-up')
self.ignore(self.DOWN_KEY + '-up')
self.ignore(self.LEFT_KEY + '-up')
self.ignore(self.RIGHT_KEY + '-up')
self._DistributedCannonGame__killLocalCannonMoveTask()
def _DistributedCannonGame__fireKeyPressed(self):
self.ignore(self.FIRE_KEY)
self.accept(self.FIRE_KEY + '-up', self._DistributedCannonGame__fireKeyReleased)
self._DistributedCannonGame__firePressed()
def _DistributedCannonGame__upKeyPressed(self):
self.ignore(self.UP_KEY)
self.accept(self.UP_KEY + '-up', self._DistributedCannonGame__upKeyReleased)
self._DistributedCannonGame__upPressed()
def _DistributedCannonGame__downKeyPressed(self):
self.ignore(self.DOWN_KEY)
self.accept(self.DOWN_KEY + '-up', self._DistributedCannonGame__downKeyReleased)
self._DistributedCannonGame__downPressed()
def _DistributedCannonGame__leftKeyPressed(self):
self.ignore(self.LEFT_KEY)
self.accept(self.LEFT_KEY + '-up', self._DistributedCannonGame__leftKeyReleased)
self._DistributedCannonGame__leftPressed()
def _DistributedCannonGame__rightKeyPressed(self):
self.ignore(self.RIGHT_KEY)
self.accept(self.RIGHT_KEY + '-up', self._DistributedCannonGame__rightKeyReleased)
self._DistributedCannonGame__rightPressed()
def _DistributedCannonGame__fireKeyReleased(self):
self.ignore(self.FIRE_KEY + '-up')
self.accept(self.FIRE_KEY, self._DistributedCannonGame__fireKeyPressed)
self._DistributedCannonGame__fireReleased()
def _DistributedCannonGame__leftKeyReleased(self):
self.ignore(self.LEFT_KEY + '-up')
self.accept(self.LEFT_KEY, self._DistributedCannonGame__leftKeyPressed)
self._DistributedCannonGame__leftReleased()
def _DistributedCannonGame__rightKeyReleased(self):
self.ignore(self.RIGHT_KEY + '-up')
self.accept(self.RIGHT_KEY, self._DistributedCannonGame__rightKeyPressed)
self._DistributedCannonGame__rightReleased()
def _DistributedCannonGame__upKeyReleased(self):
self.ignore(self.UP_KEY + '-up')
self.accept(self.UP_KEY, self._DistributedCannonGame__upKeyPressed)
self._DistributedCannonGame__upReleased()
def _DistributedCannonGame__downKeyReleased(self):
self.ignore(self.DOWN_KEY + '-up')
self.accept(self.DOWN_KEY, self._DistributedCannonGame__downKeyPressed)
self._DistributedCannonGame__downReleased()
def _DistributedCannonGame__firePressed(self):
self.notify.debug('fire pressed')
self.gameFSM.request('shoot')
def _DistributedCannonGame__upPressed(self):
self.notify.debug('up pressed')
self.upPressed = self._DistributedCannonGame__enterControlActive(self.upPressed)
def _DistributedCannonGame__downPressed(self):
self.notify.debug('down pressed')
self.downPressed = self._DistributedCannonGame__enterControlActive(self.downPressed)
def _DistributedCannonGame__leftPressed(self):
self.notify.debug('left pressed')
self.leftPressed = self._DistributedCannonGame__enterControlActive(self.leftPressed)
def _DistributedCannonGame__rightPressed(self):
self.notify.debug('right pressed')
self.rightPressed = self._DistributedCannonGame__enterControlActive(self.rightPressed)
def _DistributedCannonGame__upReleased(self):
self.notify.debug('up released')
self.upPressed = self._DistributedCannonGame__exitControlActive(self.upPressed)
def _DistributedCannonGame__downReleased(self):
self.notify.debug('down released')
self.downPressed = self._DistributedCannonGame__exitControlActive(self.downPressed)
def _DistributedCannonGame__leftReleased(self):
self.notify.debug('left released')
self.leftPressed = self._DistributedCannonGame__exitControlActive(self.leftPressed)
def _DistributedCannonGame__rightReleased(self):
self.notify.debug('right released')
self.rightPressed = self._DistributedCannonGame__exitControlActive(self.rightPressed)
def _DistributedCannonGame__enterControlActive(self, control):
return control + 1
def _DistributedCannonGame__exitControlActive(self, control):
return max(0, control - 1)
def _DistributedCannonGame__doCheat(self):
if self.cheat:
results = self._DistributedCannonGame__calcFlightResults(self.localAvId, 0)
if results['hitWhat'] == self.HIT_WATER:
self.aimPad.setColor(0.5, 0.5, 0.5, 1)
else:
self.aimPad.setColor(1, 1, 1, 1)
def _DistributedCannonGame__clearCheat(self):
self.aimPad.setColor(1, 1, 1, 1)
def _DistributedCannonGame__spawnLocalCannonMoveTask(self):
self.leftPressed = 0
self.rightPressed = 0
self.upPressed = 0
self.downPressed = 0
self.cannonMoving = 0
task = Task.Task(self._DistributedCannonGame__localCannonMoveTask)
task.lastPositionBroadcastTime = 0.0
taskMgr.add(task, self.LOCAL_CANNON_MOVE_TASK)
def _DistributedCannonGame__killLocalCannonMoveTask(self):
taskMgr.remove(self.LOCAL_CANNON_MOVE_TASK)
if self.cannonMoving:
self.sndCannonMove.stop()
self._DistributedCannonGame__clearCheat()
def _DistributedCannonGame__localCannonMoveTask(self, task):
pos = self.cannonPositionDict[self.localAvId]
oldRot = pos[0]
oldAng = pos[1]
rotVel = 0
if self.leftPressed:
rotVel += CANNON_ROTATION_VEL
if self.rightPressed:
rotVel -= CANNON_ROTATION_VEL
pos[0] += rotVel * globalClock.getDt()
if pos[0] < CANNON_ROTATION_MIN:
pos[0] = CANNON_ROTATION_MIN
elif pos[0] > CANNON_ROTATION_MAX:
pos[0] = CANNON_ROTATION_MAX
angVel = 0
if self.upPressed:
angVel += CANNON_ANGLE_VEL
if self.downPressed:
angVel -= CANNON_ANGLE_VEL
pos[1] += angVel * globalClock.getDt()
if pos[1] < CANNON_ANGLE_MIN:
pos[1] = CANNON_ANGLE_MIN
elif pos[1] > CANNON_ANGLE_MAX:
pos[1] = CANNON_ANGLE_MAX
if oldRot != pos[0] or oldAng != pos[1]:
if self.cannonMoving == 0:
self.cannonMoving = 1
base.playSfx(self.sndCannonMove, looping = 1)
self._DistributedCannonGame__updateCannonPosition(self.localAvId)
if task.time - task.lastPositionBroadcastTime > CANNON_MOVE_UPDATE_FREQ:
task.lastPositionBroadcastTime = task.time
self._DistributedCannonGame__broadcastLocalCannonPosition()
elif self.cannonMoving:
self.cannonMoving = 0
self.sndCannonMove.stop()
self._DistributedCannonGame__broadcastLocalCannonPosition()
self._DistributedCannonGame__doCheat()
return Task.cont
def _DistributedCannonGame__broadcastLocalCannonPosition(self):
self.sendUpdate('setCannonPosition', [
self.cannonPositionDict[self.localAvId][0],
self.cannonPositionDict[self.localAvId][1]])
def _DistributedCannonGame__updateCannonPosition(self, avId):
self.cannonDict[avId][0].setHpr(self.cannonPositionDict[avId][0], 0.0, 0.0)
self.cannonDict[avId][1].setHpr(0.0, self.cannonPositionDict[avId][1], 0.0)
def _DistributedCannonGame__getCameraPositionBehindCannon(self):
return Point3(self.cannonLocationDict[self.localAvId][0], CANNON_Y - 25.0, CANNON_Z + 7)
def _DistributedCannonGame__putCameraBehindCannon(self):
camera.setPos(self._DistributedCannonGame__getCameraPositionBehindCannon())
camera.setHpr(0, 0, 0)
def _DistributedCannonGame__loadToonInCannon(self, avId):
self.toonModelDict[avId].reparentTo(hidden)
head = self.toonHeadDict[avId]
head.startBlink()
head.startLookAround()
head.reparentTo(self.cannonDict[avId][1])
head.setPosHpr(0, 6, 0, 0, -45, 0)
sc = self.toonScaleDict[avId]
head.setScale(render, sc[0], sc[1], sc[2])
def _DistributedCannonGame__toRadians(self, angle):
return angle * 2.0 * math.pi / 360.0
def _DistributedCannonGame__toDegrees(self, angle):
return angle * 360.0 / 2.0 * math.pi
def _DistributedCannonGame__calcFlightResults(self, avId, launchTime):
head = self.toonHeadDict[avId]
startPos = head.getPos(render)
startHpr = head.getHpr(render)
hpr = self.cannonDict[avId][1].getHpr(render)
towerPos = self.tower.getPos(render)
rotation = self._DistributedCannonGame__toRadians(hpr[0])
angle = self._DistributedCannonGame__toRadians(hpr[1])
horizVel = INITIAL_VELOCITY * math.cos(angle)
xVel = horizVel * -math.sin(rotation)
yVel = horizVel * math.cos(rotation)
zVel = INITIAL_VELOCITY * math.sin(angle)
startVel = Vec3(xVel, yVel, zVel)
trajectory = Trajectory.Trajectory(launchTime, startPos, startVel)
towerList = [
towerPos + Point3(0, 0, BUCKET_HEIGHT),
TOWER_RADIUS,
TOWER_HEIGHT - BUCKET_HEIGHT]
(timeOfImpact, hitWhat) = self._DistributedCannonGame__calcToonImpact(trajectory, towerList)
return {
'startPos': startPos,
'startHpr': startHpr,
'startVel': startVel,
'trajectory': trajectory,
'timeOfImpact': timeOfImpact,
'hitWhat': hitWhat }
def _DistributedCannonGame__fireCannonTask(self, task):
launchTime = task.fireTime
avId = task.avId
self.notify.debug('FIRING CANNON FOR AVATAR ' + str(avId))
flightResults = self._DistributedCannonGame__calcFlightResults(avId, launchTime)
for key in flightResults:
exec "%s = flightResults['%s']" % (key, key)
self.notify.debug('start position: ' + str(startPos))
self.notify.debug('start velocity: ' + str(startVel))
self.notify.debug('time of launch: ' + str(launchTime))
self.notify.debug('time of impact: ' + str(timeOfImpact))
self.notify.debug('location of impact: ' + str(trajectory.getPos(timeOfImpact)))
if hitWhat == self.HIT_WATER:
self.notify.debug('toon will land in the water')
elif hitWhat == self.HIT_TOWER:
self.notify.debug('toon will hit the tower')
else:
self.notify.debug('toon will hit the ground')
head = self.toonHeadDict[avId]
head.stopBlink()
head.stopLookAroundNow()
head.reparentTo(hidden)
av = self.toonModelDict[avId]
av.reparentTo(render)
av.setPos(startPos)
av.setHpr(startHpr)
avatar = self.getAvatar(avId)
avatar.loop('swim')
avatar.setPosHpr(0, 0, -(avatar.getHeight() / 2.0), 0, 0, 0)
shootTask = Task.Task(self._DistributedCannonGame__shootTask)
flyTask = Task.Task(self._DistributedCannonGame__flyTask)
seqDoneTask = Task.Task(self._DistributedCannonGame__flySequenceDoneTask)
info = { }
info['avId'] = avId
info['trajectory'] = trajectory
info['launchTime'] = launchTime
info['timeOfImpact'] = timeOfImpact
info['hitWhat'] = hitWhat
info['toon'] = self.toonModelDict[avId]
info['hRot'] = self.cannonPositionDict[avId][0]
info['haveWhistled'] = 0
info['maxCamPullback'] = CAMERA_PULLBACK_MIN
(info['timeEnterTowerXY'], info['timeExitTowerXY']) = trajectory.calcEnterAndLeaveCylinderXY(self.tower.getPos(render), TOWER_RADIUS)
shootTask.info = info
flyTask.info = info
seqDoneTask.info = info
seqTask = Task.sequence(shootTask, flyTask, Task.pause(LAND_TIME), seqDoneTask)
taskMgr.add(seqTask, 'flyingToon' + str(avId))
if avId == self.localAvId:
if info['hitWhat'] == self.HIT_WATER:
self.sendUpdate('setToonWillLandInWater', [
info['timeOfImpact']])
return Task.done
def _DistributedCannonGame__calcToonImpact(self, trajectory, waterTower):
waterDiscCenter = Point3(waterTower[0])
waterDiscCenter.setZ(waterDiscCenter[2] + waterTower[2])
t_waterImpact = trajectory.checkCollisionWithDisc(waterDiscCenter, waterTower[1])
if t_waterImpact > 0:
return (t_waterImpact, self.HIT_WATER)
t_towerImpact = trajectory.checkCollisionWithCylinderSides(waterTower[0], waterTower[1], waterTower[2])
if t_towerImpact > 0:
return (t_towerImpact, self.HIT_TOWER)
t_groundImpact = trajectory.checkCollisionWithGround()
if t_groundImpact > 0:
return (t_groundImpact, self.HIT_GROUND)
else:
self.notify.error('__calcToonImpact: toon never impacts ground?')
return (self.startTime, self.HIT_GROUND)
def _DistributedCannonGame__shootTask(self, task):
base.playSfx(self.sndCannonFire)
self.dropShadowDict[task.info['avId']].reparentTo(render)
return Task.done
def _DistributedCannonGame__flyTask(self, task):
curTime = task.time + task.info['launchTime']
t = min(curTime, task.info['timeOfImpact'])
pos = task.info['trajectory'].getPos(t)
task.info['toon'].setPos(pos)
shadowPos = Point3(pos)
if t >= task.info['timeEnterTowerXY'] and t <= task.info['timeExitTowerXY'] and pos[2] >= self.tower.getPos(render)[2] + TOWER_HEIGHT:
shadowPos.setZ(self.tower.getPos(render)[2] + TOWER_HEIGHT + SHADOW_Z_OFFSET)
else:
shadowPos.setZ(SHADOW_Z_OFFSET)
self.dropShadowDict[task.info['avId']].setPos(shadowPos)
vel = task.info['trajectory'].getVel(t)
run = math.sqrt(vel[0] * vel[0] + vel[1] * vel[1])
rise = vel[2]
theta = self._DistributedCannonGame__toDegrees(math.atan(rise / run))
task.info['toon'].setHpr(task.info['hRot'], -90 + theta, 0)
if task.info['avId'] == self.localAvId:
lookAt = self.tower.getPos(render)
lookAt.setZ(lookAt.getZ() - TOWER_HEIGHT / 2.0)
towerPos = Point3(self.towerPos)
towerPos.setZ(TOWER_HEIGHT)
ttVec = Vec3(pos - towerPos)
toonTowerDist = ttVec.length()
multiplier = 0.0
if toonTowerDist < TOON_TOWER_THRESHOLD:
up = Vec3(0.0, 0.0, 1.0)
perp = up.cross(vel)
perp.normalize()
if ttVec.dot(perp) > 0.0:
perp = Vec3(-perp[0], -perp[1], -perp[2])
a = 1.0 - toonTowerDist / TOON_TOWER_THRESHOLD
a_2 = a * a
multiplier = -2.0 * a_2 * a + 3 * a_2
lookAt = lookAt + perp * multiplier * MAX_LOOKAT_OFFSET
foo = Vec3(pos - lookAt)
foo.normalize()
task.info['maxCamPullback'] = max(task.info['maxCamPullback'], CAMERA_PULLBACK_MIN + multiplier * (CAMERA_PULLBACK_MAX - CAMERA_PULLBACK_MIN))
foo = foo * task.info['maxCamPullback']
camPos = pos + Point3(foo)
camera.setPos(camPos)
camera.lookAt(pos)
if task.info['haveWhistled'] == 0:
if -vel[2] > WHISTLE_SPEED:
if t < task.info['timeOfImpact'] - 0.5:
task.info['haveWhistled'] = 1
base.playSfx(self.sndWhizz)
if t == task.info['timeOfImpact']:
if task.info['haveWhistled']:
self.sndWhizz.stop()
self.dropShadowDict[task.info['avId']].reparentTo(hidden)
avatar = self.getAvatar(task.info['avId'])
if task.info['hitWhat'] == self.HIT_WATER:
avatar.loop('neutral')
self.splash.setPos(task.info['toon'].getPos())
self.splash.setScale(2)
self.splash.play()
base.playSfx(self.sndHitWater)
task.info['toon'].setHpr(task.info['hRot'], 0, 0)
self._DistributedCannonGame__somebodyWon(task.info['avId'])
elif task.info['hitWhat'] == self.HIT_TOWER:
toon = task.info['toon']
pos = toon.getPos()
ttVec = Vec3(pos - self.towerPos)
ttVec.setZ(0)
ttVec.normalize()
h = rad2Deg(math.asin(ttVec[0]))
toon.setHpr(h, 94, 0)
deltaZ = TOWER_HEIGHT - BUCKET_HEIGHT
sf = min(max(pos[2] - BUCKET_HEIGHT, 0), deltaZ) / deltaZ
hitPos = pos + Point3(ttVec * 0.75 * sf)
toon.setPos(hitPos)
hitPos.setZ(hitPos[2] - 1.0)
s = Sequence(Wait(0.5), toon.posInterval(duration = LAND_TIME - 0.5, pos = hitPos, blendType = 'easeIn'))
self.toonIntervalDict[task.info['avId']] = s
s.start()
avatar.iPos()
avatar.pose('slip-forward', 25)
base.playSfx(self.sndHitTower)
elif task.info['hitWhat'] == self.HIT_GROUND:
task.info['toon'].setP(render, -150.0)
self.dustCloud.setPos(task.info['toon'], 0, 0, -2.5)
self.dustCloud.setScale(0.34999999999999998)
self.dustCloud.play()
base.playSfx(self.sndHitGround)
avatar.setPlayRate(2.0, 'run')
avatar.loop('run')
return Task.done
return Task.cont
def _DistributedCannonGame__flySequenceDoneTask(self, task):
self.airborneToons -= 1
if self.gameFSM.getCurrentState().getName() == 'waitForToonsToLand':
if 0 == self.airborneToons:
self.gameOver()
else:
self._DistributedCannonGame__loadToonInCannon(task.info['avId'])
if task.info['avId'] == self.localAvId:
self.gameFSM.request('aim')
return Task.done
def _DistributedCannonGame__startRewardCountdown(self):
taskMgr.remove(self.REWARD_COUNTDOWN_TASK)
taskMgr.add(self._DistributedCannonGame__updateRewardCountdown, self.REWARD_COUNTDOWN_TASK)
def _DistributedCannonGame__killRewardCountdown(self):
taskMgr.remove(self.REWARD_COUNTDOWN_TASK)
def _DistributedCannonGame__updateRewardCountdown(self, task):
curTime = self.getCurrentGameTime()
if self.clockStopTime is not None:
if self.clockStopTime < curTime:
self._DistributedCannonGame__killRewardCountdown()
curTime = self.clockStopTime
if not hasattr(task, 'curScore'):
task.curScore = CannonGameGlobals.calcScore(curTime)
score = CannonGameGlobals.calcScore(curTime)
self.rewardPanel['text'] = str(score)
if task.curScore != score:
if hasattr(self, 'jarIval'):
self.jarIval.finish()
s = self.rewardPanel.getScale()
self.jarIval = Parallel(Sequence(self.rewardPanel.scaleInterval(0.14999999999999999, s * 3.0 / 4.0, blendType = 'easeOut'), self.rewardPanel.scaleInterval(0.14999999999999999, s, blendType = 'easeIn')), SoundInterval(self.sndRewardTick), name = 'cannonGameRewardJarThrob')
self.jarIval.start()
task.curScore = score
return Task.cont
def _DistributedCannonGame__startIntro(self):
self.T_WATER = 1
self.T_WATER2LONGVIEW = 1
self.T_LONGVIEW = 1
self.T_LONGVIEW2TOONHEAD = 2
self.T_TOONHEAD = 2
self.T_TOONHEAD2CANNONBACK = 2
taskLookInWater = Task.Task(self._DistributedCannonGame__taskLookInWater)
taskPullBackFromWater = Task.Task(self._DistributedCannonGame__taskPullBackFromWater)
taskFlyUpToToon = Task.Task(self._DistributedCannonGame__flyUpToToon)
taskFlyToBackOfCannon = Task.Task(self._DistributedCannonGame__flyToBackOfCannon)
commonData = { }
taskLookInWater.data = commonData
taskPullBackFromWater.data = commonData
taskFlyUpToToon.data = commonData
taskFlyToBackOfCannon.data = commonData
introTask = Task.sequence(taskLookInWater, Task.pause(self.T_WATER), taskPullBackFromWater, Task.pause(self.T_WATER2LONGVIEW + self.T_LONGVIEW), taskFlyUpToToon, Task.pause(self.T_LONGVIEW2TOONHEAD + self.T_TOONHEAD), taskFlyToBackOfCannon)
taskMgr.add(introTask, self.INTRO_TASK_NAME)
def _DistributedCannonGame__stopIntro(self):
taskMgr.remove(self.INTRO_TASK_NAME)
taskMgr.remove(self.INTRO_TASK_NAME_CAMERA_LERP)
camera.wrtReparentTo(render)
def _DistributedCannonGame__spawnCameraLookAtLerp(self, targetPos, targetLookAt, duration):
oldPos = camera.getPos()
oldHpr = camera.getHpr()
camera.setPos(targetPos)
camera.lookAt(targetLookAt)
targetHpr = camera.getHpr()
camera.setPos(oldPos)
camera.setHpr(oldHpr)
camera.lerpPosHpr(Point3(targetPos), targetHpr, duration, blendType = 'easeInOut', task = self.INTRO_TASK_NAME_CAMERA_LERP)
def _DistributedCannonGame__taskLookInWater(self, task):
task.data['cannonCenter'] = Point3(0, CANNON_Y, CANNON_Z)
task.data['towerWaterCenter'] = Point3(self.towerPos + Point3(0, 0, TOWER_HEIGHT))
task.data['vecTowerToCannon'] = Point3(task.data['cannonCenter'] - task.data['towerWaterCenter'])
vecAwayFromCannons = Vec3(Point3(0, 0, 0) - task.data['vecTowerToCannon'])
vecAwayFromCannons.setZ(0.0)
vecAwayFromCannons.normalize()
camLoc = Point3(vecAwayFromCannons * 20) + Point3(0, 0, 20)
camLoc = camLoc + task.data['towerWaterCenter']
camera.setPos(camLoc)
camera.lookAt(task.data['towerWaterCenter'])
task.data['vecAwayFromCannons'] = vecAwayFromCannons
return Task.done
def _DistributedCannonGame__taskPullBackFromWater(self, task):
camLoc = Point3(task.data['vecAwayFromCannons'] * 40) + Point3(0, 0, 20)
camLoc = camLoc + task.data['towerWaterCenter']
lookAt = task.data['cannonCenter']
self._DistributedCannonGame__spawnCameraLookAtLerp(camLoc, lookAt, self.T_WATER2LONGVIEW)
return Task.done
def _DistributedCannonGame__flyUpToToon(self, task):
headPos = self.toonHeadDict[self.localAvId].getPos(render)
camLoc = headPos + Point3(0, 5, 0)
lookAt = Point3(headPos)
self._DistributedCannonGame__spawnCameraLookAtLerp(camLoc, lookAt, self.T_LONGVIEW2TOONHEAD)
return Task.done
def _DistributedCannonGame__flyToBackOfCannon(self, task):
lerpNode = hidden.attachNewNode('CannonGameCameraLerpNode')
lerpNode.reparentTo(render)
lerpNode.setPos(self.cannonLocationDict[self.localAvId] + Point3(0, 1, 0))
relCamPos = camera.getPos(lerpNode)
relCamHpr = camera.getHpr(lerpNode)
startRotation = lerpNode.getHpr()
endRotation = Point3(-180, 0, 0)
lerpNode.setHpr(endRotation)
camera.setPos(self._DistributedCannonGame__getCameraPositionBehindCannon())
endPos = camera.getPos(lerpNode)
lerpNode.setHpr(startRotation)
camera.reparentTo(lerpNode)
camera.setPos(relCamPos)
camera.setHpr(relCamHpr)
lerpNode.lerpHpr(endRotation, self.T_TOONHEAD2CANNONBACK, blendType = 'easeInOut', task = self.INTRO_TASK_NAME_CAMERA_LERP)
camera.lerpPos(endPos, self.T_TOONHEAD2CANNONBACK, blendType = 'easeInOut', task = self.INTRO_TASK_NAME_CAMERA_LERP)
return Task.done
def __init__(self, chatMgr):
self.chatMgr = chatMgr
self.whisperAvatarName = None
self.whisperAvatarId = None
gui = loader.loadModelOnce('phase_3.5/models/gui/chat_input_gui')
self.chatFrame = DirectFrame(image = gui.find('**/Chat_Bx_FNL'), relief = None, pos = (-1.083, 0, 0.80400000000000005), sortOrder = FOREGROUND_SORT_INDEX)
self.chatFrame.hide()
self.chatButton = DirectButton(parent = self.chatFrame, image = (gui.find('**/ChtBx_ChtBtn_UP'), gui.find('**/ChtBx_ChtBtn_DN'), gui.find('**/ChtBx_ChtBtn_RLVR')), pos = (0.182, 0, -0.087999999999999995), relief = None, text = ('', Localizer.ChatInputNormalSayIt, Localizer.ChatInputNormalSayIt), text_scale = 0.059999999999999998, text_fg = Vec4(1, 1, 1, 1), text_shadow = Vec4(0, 0, 0, 1), text_pos = (0, -0.089999999999999997), textMayChange = 0, command = self._ChatInputNormal__chatButtonPressed)
self.cancelButton = DirectButton(parent = self.chatFrame, image = (gui.find('**/CloseBtn_UP'), gui.find('**/CloseBtn_DN'), gui.find('**/CloseBtn_Rllvr')), pos = (-0.151, 0, -0.087999999999999995), relief = None, text = ('', Localizer.ChatInputNormalCancel, Localizer.ChatInputNormalCancel), text_scale = 0.059999999999999998, text_fg = Vec4(1, 1, 1, 1), text_shadow = Vec4(0, 0, 0, 1), text_pos = (0, -0.089999999999999997), textMayChange = 0, command = self._ChatInputNormal__cancelButtonPressed)
self.whisperLabel = DirectLabel(parent = self.chatFrame, pos = (0.02, 0, 0.23000000000000001), relief = FLAT, frameColor = (1, 1, 0.5, 1), frameSize = (-0.22, 0.22, -0.070000000000000007, 0.050000000000000003), text = Localizer.ChatInputNormalWhisper, text_scale = 0.050000000000000003, text_fg = Vec4(0, 0, 0, 1), text_wordwrap = 7.5, textMayChange = 1)
self.whisperLabel.hide()
self.chatEntry = DirectEntry(parent = self.chatFrame, relief = None, scale = 0.050000000000000003, pos = (-0.20000000000000001, 0, 0.11), entryFont = ToontownGlobals.getToonFont(), width = 8.5999999999999996, numLines = 3, cursorKeys = 0, backgroundFocus = 0, command = self.sendChat)
self.chatEntry.bind(OVERFLOW, self.chatOverflow)
self.chatEntry.bind(TYPE, self.typeCallback)
gui.removeNode()
return None
class QTNode:
font = ToontownGlobals.getToonFont()
def __init__(self, name):
self.name = name
self.width = 0.0
self.selected = None
self.itemHeight = 0.0
self.phraseList = []
self.nodepath = None
self.callback = None
self.speaking = 1
self.buttons = []
self.pos = (0, 0, 0)
self.popupInfo = None
def _QTNode__findPhrasePair(self, key):
phrasePair = None
if isinstance(key, types.StringType):
for pp in self.phraseList:
if pp[0] == key:
phrasePair = pp
break
elif key < len(self.phraseList):
phrasePair = self.phraseList[key]
return phrasePair
def __getitem__(self, key):
phrasePair = self._QTNode__findPhrasePair(key)
if phrasePair == None:
return None
else:
return phrasePair[1]
def __setitem__(self, key, value):
phrasePair = self._QTNode__findPhrasePair(key)
if phrasePair == None:
self.phraseList.append([
key,
value,
QT_TEXT_NODE])
else:
phrasePair[1] = value
phrasePair[2] = QT_TEXT_NODE
def addMenu(self, key, value, type = QT_MENU_NODE):
phrasePair = self._QTNode__findPhrasePair(key)
if phrasePair == None:
phrasePair = self.phraseList.append([
key,
value,
type])
else:
phrasePair[1] = value
phrasePair[2] = type
def getPhrase(self, index):
pp = self._QTNode__findPhrasePair(index)
if pp == None:
return ''
elif pp[2] in MENU_NODES_LIST:
return ''
else:
return pp[0]
def _QTNode__createDisplayText(self, phrasePair):
text = phrasePair[0]
if phrasePair[2] in MENU_NODES_LIST:
pass
1
if not phrasePair[1].isTerminal():
text = text + '...'
return text
def isTerminal(self):
return self == QTSend
def isSpeaking(self):
return self.speaking
def createMenu(self):
self.deleteMenu()
self.nodepath = hidden.attachNewNode('QTNode-' + self.name)
l = 0
r = 0
t = 0
b = 0
text = TextNode('qtmenu')
text.freeze()
text.setFont(QTNode.font)
for pp in self.phraseList:
dText = self._QTNode__createDisplayText(pp)
text.setText(dText)
bounds = text.getCardActual()
if pp[2] in MENU_NODES_LIST:
arrowPad = 1.0
else:
arrowPad = 0.0
l = min(l, bounds[0])
r = max(r, bounds[1] + arrowPad)
b = min(b, bounds[2])
t = max(t, bounds[3])
del text
z = 0
sf = 0.055
padx = 0.25
padz = 0.10000000000000001
self.width = (r + padx) * sf
self.itemHeight = -(padz + padz + (t - b)) * sf
dz = -(padz + padz + (t - b)) * sf
index = 0
for pp in self.phraseList:
frameColor = (0.80000000000000004, 0.80000000000000004, 1, 1)
rolloverColor = (0.90000000000000002, 0.90000000000000002, 1, 1)
text_fg = (0, 0, 0, 1.0)
state = NORMAL
dText = self._QTNode__createDisplayText(pp)
if pp[2] in MENU_NODES_LIST:
relief = RAISED
image = ('phase_3/models/props/page-arrow', 'poly')
image_pos = (r - padx, 0, (t - b) / 4.0)
else:
relief = FLAT
image = None
image_pos = (0, 0, 0)
if pp[2] == QT_DISABLED_NODE:
frameColor = ((0.80000000000000004, 0.80000000000000004, 0.80000000000000004, 0.5),)
rolloverColor = (0.90000000000000002, 0.90000000000000002, 1, 0.5)
text_fg = (0.5, 0.5, 0.5, 1.0)
relief = SUNKEN
btn = DirectButton(parent = self.nodepath, state = state, text = dText, image = image, image_pos = image_pos, text_font = QTNode.font, text_align = TextNode.ALeft, textMayChange = 0, frameColor = frameColor, frameSize = (l - padx, r + padx, b - padz, t + padz), relief = relief, pos = (0.0, 0.0, z), text_fg = text_fg, scale = 0.055, extraArgs = [
index])
btn.frameStyle[2].setColor(rolloverColor[0], rolloverColor[1], rolloverColor[2], rolloverColor[3])
btn.updateFrameStyle()
btn.bind(EXIT, self._QTNode__buttonExited, extraArgs = [
index,
pp[2]])
btn.bind(ENTER, self._QTNode__buttonEntered, extraArgs = [
index,
pp[2]])
btn.bind(B1PRESS, self._QTNode__buttonSelected, extraArgs = [
index,
pp[2]])
self.buttons.append(btn)
z = z + dz
index += 1
def setPos(self, x, y, z):
self.pos = Point3(x, y, z)
self.nodepath.setPos(x, y, z)
def getPos(self):
return self.pos
def deleteMenu(self):
for button in self.buttons:
button.destroy()
self.buttons = []
if self.nodepath:
self.nodepath.removeNode()
if self.popupInfo:
self.popupInfo.destroy()
self.popupInfo = None
def destroy(self):
self.deleteMenu()
del self.buttons
del self.nodepath
def enterPopupInfo(self):
if self.popupInfo == None:
buttons = loader.loadModelOnce('phase_3/models/gui/dialog_box_buttons_gui')
okButtonImage = (buttons.find('**/ChtBx_OKBtn_UP'), buttons.find('**/ChtBx_OKBtn_DN'), buttons.find('**/ChtBx_OKBtn_Rllvr'))
self.popupInfo = DirectFrame(parent = hidden, relief = None, state = 'normal', text = Localizer.QTPopupEmoteMessage, frameSize = (-1, 1, -1, 1), geom = getDefaultDialogGeom(), geom_color = ToontownGlobals.GlobalDialogColor, geom_scale = (0.88, 1, 0.45000000000000001), geom_pos = (0, 0, -0.080000000000000002), text_scale = 0.080000000000000002)
DirectButton(self.popupInfo, image = okButtonImage, relief = None, text = Localizer.QTPopupEmoteMessageOK, text_scale = 0.050000000000000003, text_pos = (0.0, -0.10000000000000001), textMayChange = 0, pos = (0.0, 0.0, -0.16), command = self._QTNode__handlePopupEmoteMessageOK)
buttons.removeNode()
self.popupInfo.reparentTo(aspect2d)
def _QTNode__handlePopupEmoteMessageOK(self):
self.popupInfo.reparentTo(hidden)
def _QTNode__buttonSelected(self, index, type, event):
if type == QT_DISABLED_NODE:
self.enterPopupInfo()
return None
messenger.send('QTNode_selected', [
self,
index])
self.selected = self[index]
def _QTNode__buttonEntered(self, index, type, event):
if self.selected:
try:
self.selected.nodepath.reparentTo(hidden)
except AttributeError:
pass
if type == QT_DISABLED_NODE:
pass
1
if type != QT_TEXT_NODE:
self._QTNode__buttonSelected(index, type, event)
def _QTNode__buttonExited(self, index, type, event):
pass
def __init__(self, av=None, position=0, paid=0):
DirectButton.__init__(self,
relief=None,
text='',
text_font=ToontownGlobals.getSignFont())
self.initialiseoptions(AvatarChoice)
self.hasPaid = paid
if not av:
self.create = 1
self.name = ''
self.dna = None
else:
self.create = 0
self.name = av.name
self.dna = AvatarDNA.AvatarDNA(av.dna)
self.wantName = av.wantName
self.approvedName = av.approvedName
self.rejectedName = av.rejectedName
self.allowedName = av.allowedName
self.position = position
self.doneEvent = 'avChoicePanel-' + str(self.position)
self.deleteWithPasswordFrame = None
self.pickAToonGui = loader.loadModelOnce(
'phase_3/models/gui/pick_a_toon_gui')
self['image'] = self.pickAToonGui.find('**/av-chooser_Square_UP')
self.setScale(1.01)
if self.create:
self['command'] = self._AvatarChoice__handleCreate
self['text'] = (Localizer.AvatarChoiceMakeAToon, )
self['text_pos'] = (0, 0)
self['text0_scale'] = 0.10000000000000001
self['text1_scale'] = 0.12
self['text2_scale'] = 0.12
self['text0_fg'] = (0, 1, 0.80000000000000004, 0.5)
self['text1_fg'] = (0, 1, 0.80000000000000004, 1)
self['text2_fg'] = (0.29999999999999999, 1, 0.90000000000000002, 1)
else:
self['command'] = self._AvatarChoice__handleChoice
self['text'] = ('', Localizer.AvatarChoicePlayThisToon,
Localizer.AvatarChoicePlayThisToon)
self['text_scale'] = 0.12
self['text_fg'] = (1, 0.90000000000000002, 0.10000000000000001, 1)
self.nameText = DirectLabel(
parent=self,
relief=None,
scale=0.089999999999999997,
pos=(0, 0, 0.27000000000000002),
text=self.name,
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
text_wordwrap=7.5,
text_font=ToontownGlobals.getToonFont(),
state=DISABLED)
if self.approvedName != '':
self.nameText['text'] = self.approvedName
guiButton = loader.loadModelOnce('phase_3/models/gui/quit_button')
self.nameYourToonButton = DirectButton(
parent=self,
relief=None,
image=(guiButton.find('**/QuitBtn_UP'),
guiButton.find('**/QuitBtn_DN'),
guiButton.find('**/QuitBtn_RLVR')),
text=(Localizer.AvatarChoiceNameYourToon,
Localizer.AvatarChoiceNameYourToon,
Localizer.AvatarChoiceNameYourToon),
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
text_scale=0.14999999999999999,
text_pos=(0, 0.029999999999999999),
text_font=ToontownGlobals.getInterfaceFont(),
pos=(-0.20000000000000001, 0, -0.29999999999999999),
scale=0.45000000000000001,
image_scale=(2, 1, 3),
command=self._AvatarChoice__handleNameYourToon)
guiButton.removeNode()
self.statusText = DirectLabel(
parent=self,
relief=None,
scale=0.089999999999999997,
pos=(0, 0, -0.23999999999999999),
text='',
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
text_wordwrap=7.5,
text_font=ToontownGlobals.getToonFont(),
state=DISABLED)
if self.wantName != '':
self.nameYourToonButton.hide()
self.statusText['text'] = Localizer.AvatarChoiceNameReview
elif self.approvedName != '':
self.nameYourToonButton.hide()
self.statusText['text'] = Localizer.AvatarChoiceNameApproved
elif self.rejectedName != '':
self.nameYourToonButton.hide()
self.statusText['text'] = Localizer.AvatarChoiceNameRejected
elif self.allowedName == 1 and toonbase.tcr.allowFreeNames(
) or self.hasPaid:
self.nameYourToonButton.show()
self.statusText['text'] = ''
else:
self.nameYourToonButton.hide()
self.statusText['text'] = ''
self.head = hidden.attachNewNode('head')
self.head.setPosHprScale(0, 5, -0.10000000000000001, 180, 0, 0,
0.23999999999999999, 0.23999999999999999,
0.23999999999999999)
self.head.reparentTo(self.stateNodePath[0], 20)
self.head.instanceTo(self.stateNodePath[1], 20)
self.head.instanceTo(self.stateNodePath[2], 20)
self.headModel = ToonHead.ToonHead()
self.headModel.setupHead(self.dna, forGui=1)
self.headModel.reparentTo(self.head)
self.headModel.startBlink()
self.headModel.startLookAround()
trashcanGui = loader.loadModelOnce(
'phase_3/models/gui/trashcan_gui')
self.deleteButton = DirectButton(
parent=self,
image=(trashcanGui.find('**/TrashCan_CLSD'),
trashcanGui.find('**/TrashCan_OPEN'),
trashcanGui.find('**/TrashCan_RLVR')),
text=('', Localizer.AvatarChoiceDelete,
Localizer.AvatarChoiceDelete),
text_fg=(1, 1, 1, 1),
text_shadow=(0, 0, 0, 1),
text_scale=0.14999999999999999,
text_pos=(0, -0.10000000000000001),
text_font=ToontownGlobals.getInterfaceFont(),
relief=None,
pos=(0.27000000000000002, 0, -0.25),
scale=0.45000000000000001,
command=self._AvatarChoice__handleDelete)
trashcanGui.removeNode()
self.resetFrameSize()
return None
def getFont(self):
return ToontownGlobals.getToonFont()
def __init__(self, av = None, position = 0, paid = 0):
DirectButton.__init__(self, relief = None, text = '', text_font = ToontownGlobals.getSignFont())
self.initialiseoptions(AvatarChoice)
self.hasPaid = paid
if not av:
self.create = 1
self.name = ''
self.dna = None
else:
self.create = 0
self.name = av.name
self.dna = AvatarDNA.AvatarDNA(av.dna)
self.wantName = av.wantName
self.approvedName = av.approvedName
self.rejectedName = av.rejectedName
self.allowedName = av.allowedName
self.position = position
self.doneEvent = 'avChoicePanel-' + str(self.position)
self.deleteWithPasswordFrame = None
self.pickAToonGui = loader.loadModelOnce('phase_3/models/gui/pick_a_toon_gui')
self['image'] = self.pickAToonGui.find('**/av-chooser_Square_UP')
self.setScale(1.01)
if self.create:
self['command'] = self._AvatarChoice__handleCreate
self['text'] = (Localizer.AvatarChoiceMakeAToon,)
self['text_pos'] = (0, 0)
self['text0_scale'] = 0.10000000000000001
self['text1_scale'] = 0.12
self['text2_scale'] = 0.12
self['text0_fg'] = (0, 1, 0.80000000000000004, 0.5)
self['text1_fg'] = (0, 1, 0.80000000000000004, 1)
self['text2_fg'] = (0.29999999999999999, 1, 0.90000000000000002, 1)
else:
self['command'] = self._AvatarChoice__handleChoice
self['text'] = ('', Localizer.AvatarChoicePlayThisToon, Localizer.AvatarChoicePlayThisToon)
self['text_scale'] = 0.12
self['text_fg'] = (1, 0.90000000000000002, 0.10000000000000001, 1)
self.nameText = DirectLabel(parent = self, relief = None, scale = 0.089999999999999997, pos = (0, 0, 0.27000000000000002), text = self.name, text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), text_wordwrap = 7.5, text_font = ToontownGlobals.getToonFont(), state = DISABLED)
if self.approvedName != '':
self.nameText['text'] = self.approvedName
guiButton = loader.loadModelOnce('phase_3/models/gui/quit_button')
self.nameYourToonButton = DirectButton(parent = self, relief = None, image = (guiButton.find('**/QuitBtn_UP'), guiButton.find('**/QuitBtn_DN'), guiButton.find('**/QuitBtn_RLVR')), text = (Localizer.AvatarChoiceNameYourToon, Localizer.AvatarChoiceNameYourToon, Localizer.AvatarChoiceNameYourToon), text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), text_scale = 0.14999999999999999, text_pos = (0, 0.029999999999999999), text_font = ToontownGlobals.getInterfaceFont(), pos = (-0.20000000000000001, 0, -0.29999999999999999), scale = 0.45000000000000001, image_scale = (2, 1, 3), command = self._AvatarChoice__handleNameYourToon)
guiButton.removeNode()
self.statusText = DirectLabel(parent = self, relief = None, scale = 0.089999999999999997, pos = (0, 0, -0.23999999999999999), text = '', text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), text_wordwrap = 7.5, text_font = ToontownGlobals.getToonFont(), state = DISABLED)
if self.wantName != '':
self.nameYourToonButton.hide()
self.statusText['text'] = Localizer.AvatarChoiceNameReview
elif self.approvedName != '':
self.nameYourToonButton.hide()
self.statusText['text'] = Localizer.AvatarChoiceNameApproved
elif self.rejectedName != '':
self.nameYourToonButton.hide()
self.statusText['text'] = Localizer.AvatarChoiceNameRejected
elif self.allowedName == 1 and toonbase.tcr.allowFreeNames() or self.hasPaid:
self.nameYourToonButton.show()
self.statusText['text'] = ''
else:
self.nameYourToonButton.hide()
self.statusText['text'] = ''
self.head = hidden.attachNewNode('head')
self.head.setPosHprScale(0, 5, -0.10000000000000001, 180, 0, 0, 0.23999999999999999, 0.23999999999999999, 0.23999999999999999)
self.head.reparentTo(self.stateNodePath[0], 20)
self.head.instanceTo(self.stateNodePath[1], 20)
self.head.instanceTo(self.stateNodePath[2], 20)
self.headModel = ToonHead.ToonHead()
self.headModel.setupHead(self.dna, forGui = 1)
self.headModel.reparentTo(self.head)
self.headModel.startBlink()
self.headModel.startLookAround()
trashcanGui = loader.loadModelOnce('phase_3/models/gui/trashcan_gui')
self.deleteButton = DirectButton(parent = self, image = (trashcanGui.find('**/TrashCan_CLSD'), trashcanGui.find('**/TrashCan_OPEN'), trashcanGui.find('**/TrashCan_RLVR')), text = ('', Localizer.AvatarChoiceDelete, Localizer.AvatarChoiceDelete), text_fg = (1, 1, 1, 1), text_shadow = (0, 0, 0, 1), text_scale = 0.14999999999999999, text_pos = (0, -0.10000000000000001), text_font = ToontownGlobals.getInterfaceFont(), relief = None, pos = (0.27000000000000002, 0, -0.25), scale = 0.45000000000000001, command = self._AvatarChoice__handleDelete)
trashcanGui.removeNode()
self.resetFrameSize()
return None
