Пример #1
0
 def __swapTorso(self, offset):
     gender = self.toon.style.getGender()
     if not self.clothesPicked:
         length = len(AvatarDNA.toonTorsoTypes[6:])
         torsoOffset = 6
     else:
         if gender == 'm':
             length = len(AvatarDNA.toonTorsoTypes[:3])
             torsoOffset = 0
             if self.dna.armColor not in AvatarDNA.defaultBoyColorList:
                 self.dna.armColor = AvatarDNA.defaultBoyColorList[0]
             if self.dna.legColor not in AvatarDNA.defaultBoyColorList:
                 self.dna.legColor = AvatarDNA.defaultBoyColorList[0]
             if self.dna.headColor not in AvatarDNA.defaultBoyColorList:
                 self.dna.headColor = AvatarDNA.defaultBoyColorList[0]
             if AvatarDNA.isValidBoyShirt(self.toon.style.topTex) == 0:
                 pair = random.choice(AvatarDNA.BoyShirts)
                 self.toon.style.topTex = pair[0]
                 self.toon.style.sleeveTex = pair[1]
             clength = len(AvatarDNA.BoyShorts)
             if self.toon.style.botTex >= clength:
                 self.toon.style.botTex = whrandom.randint(0, clength - 1)
         else:
             length = len(AvatarDNA.toonTorsoTypes[3:6])
             if self.toon.style.torso[1] == 'd':
                 torsoOffset = 3
             else:
                 torsoOffset = 0
             if self.dna.armColor not in AvatarDNA.defaultGirlColorList:
                 self.dna.armColor = AvatarDNA.defaultGirlColorList[0]
             if self.dna.legColor not in AvatarDNA.defaultGirlColorList:
                 self.dna.legColor = AvatarDNA.defaultGirlColorList[0]
             if self.dna.headColor not in AvatarDNA.defaultGirlColorList:
                 self.dna.headColor = AvatarDNA.defaultGirlColorList[0]
             if AvatarDNA.isValidBoyShirt(self.toon.style.topTex) == 0:
                 pair = random.choice(AvatarDNA.GirlShirts)
                 self.toon.style.topTex = pair[0]
                 self.toon.style.sleeveTex = pair[1]
             clength = len(AvatarDNA.GirlBottoms)
             if self.toon.style.botTex >= clength:
                 if self.toon.style.torso[1] == 'd':
                     self.toon.style.botTex = AvatarDNA.getRandomGirlBottom(
                         AvatarDNA.SKIRT)
                     torsoOffset = 3
                 else:
                     self.toon.style.botTex = AvatarDNA.getRandomGirlBottom(
                         AvatarDNA.SHORTS)
                     torsoOffset = 0
     self.torsoChoice = (self.torsoChoice + offset) % length
     self.__updateScrollButtons(self.torsoChoice, length, self.torsoStart,
                                self.torsoLButton, self.torsoRButton)
     torso = AvatarDNA.toonTorsoTypes[torsoOffset + self.torsoChoice]
     self.dna.torso = torso
     self.toon.swapToonTorso(torso)
     self.toon.loop('neutral', 0)
     self.toon.swapToonColor(self.dna)
Пример #2
0
 def setupScrollInterface(self):
     self.dna = self.toon.getStyle()
     gender = self.dna.getGender()
     if gender != self.gender:
         self.tops = AvatarDNA.getRandomizedTops(gender, tailorId=AvatarDNA.MAKE_A_TOON)
         self.bottoms = AvatarDNA.getRandomizedBottoms(gender, tailorId=AvatarDNA.MAKE_A_TOON)
         self.gender = gender
         self.topChoice = 0
         self.bottomChoice = 0
     self.setupButtons()
Пример #3
0
 def setupScrollInterface(self):
     self.dna = self.toon.getStyle()
     gender = self.dna.getGender()
     if gender != self.gender:
         self.tops = AvatarDNA.getRandomizedTops(gender, tailorId = AvatarDNA.MAKE_A_TOON)
         self.bottoms = AvatarDNA.getRandomizedBottoms(gender, tailorId = AvatarDNA.MAKE_A_TOON)
         self.gender = gender
         self.topChoice = 0
         self.bottomChoice = 0
     
     self.setupButtons()
    def setupScrollInterface(self):
        self.dna = self.toon.getStyle()
        gender = self.dna.getGender()
        if self.swapEvent != None:
            self.tops = AvatarDNA.getTops(gender, tailorId=self.tailorId)
            self.bottoms = AvatarDNA.getBottoms(gender, tailorId=self.tailorId)
            self.gender = gender
            self.topChoice = -1
            self.bottomChoice = -1

        self.setupButtons()
Пример #5
0
 def setupScrollInterface(self):
     self.dna = self.toon.getStyle()
     gender = self.dna.getGender()
     if self.swapEvent != None:
         self.tops = AvatarDNA.getTops(gender, tailorId = self.tailorId)
         self.bottoms = AvatarDNA.getBottoms(gender, tailorId = self.tailorId)
         self.gender = gender
         self.topChoice = -1
         self.bottomChoice = -1
     
     self.setupButtons()
def createNPC(air, npcId, desc, zoneId, posIndex=0, questCallback=None):
    import DistributedNPCToonAI
    import DistributedNPCClerkAI
    import DistributedNPCTailorAI
    import DistributedNPCBlockerAI
    (zoneId, name, dnaType, gender, protected, type) = desc
    if type == NPC_REGULAR:
        npc = DistributedNPCToonAI.DistributedNPCToonAI(
            air, npcId, questCallback=questCallback)
    elif type == NPC_HQ:
        npc = DistributedNPCToonAI.DistributedNPCToonAI(
            air, npcId, questCallback=questCallback, hq=1)
    elif type == NPC_CLERK:
        npc = DistributedNPCClerkAI.DistributedNPCClerkAI(air, npcId)
    elif type == NPC_TAILOR:
        npc = DistributedNPCTailorAI.DistributedNPCTailorAI(air, npcId)
    elif type == NPC_BLOCKER:
        npc = DistributedNPCBlockerAI.DistributedNPCBlockerAI(air, npcId)
    else:
        print 'createNPC() error!!!'
    npc.setName(name)
    dna = AvatarDNA.AvatarDNA()
    if dnaType == 'r':
        dnaList = getRandomDNA(npcId, gender)
    else:
        dnaList = dnaType
    dna.newToonFromProperties(*dnaList)
    npc.setDNAString(dna.makeNetString())
    npc.setHp(15)
    npc.setMaxHp(15)
    npc.setPositionIndex(posIndex)
    npc.generateWithRequired(zoneId)
    npc.d_setAnimState('neutral', 1.0)
    return npc
 def parseLoadSuit(self, line):
     (token, name, suitType) = line
     suit = Suit.Suit()
     dna = AvatarDNA.AvatarDNA()
     dna.newSuit(suitType)
     suit.setDNA(dna)
     self.setVar(name, suit)
Пример #8
0
 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
Пример #9
0
    def playTutorialReward_3(self, value):
        self.tutRewardDialog_2.cleanup()
        import Toon, AvatarDNA

        def doneChat1(page, elapsed=0):
            self.track2.start()

        def doneChat2(elapsed):
            self.track2.pause()
            self.track3.start()

        def uniqueName(hook):
            return 'TutorialTom-' + hook

        self.tutorialTom = Toon.Toon()
        dna = AvatarDNA.AvatarDNA()
        dnaList = ('dls', 'ms', 'm', 'm', 7, 0, 7, 7, 2, 6, 2, 6, 2, 16)
        dna.newToonFromProperties(*dnaList)
        self.tutorialTom.setDNA(dna)
        self.tutorialTom.setName(Localizer.NPCToonNames[20000])
        self.tutorialTom.uniqueName = uniqueName
        questList = self.rewardPanel.getQuestIntervalList(toonbase.localToon, [
         0, 1])
        if questList:
            self.track1 = Sequence(Wait(1.0), Func(self.rewardPanel.initQuestFrame, toonbase.localToon, copy.deepcopy(toonbase.localToon.quests)), Wait(1.0), Sequence(questList), Wait(1.0), Func(self.rewardPanel.hide), Func(camera.setPosHpr, render, 34, 19.88, 3.48, 270.0, 60.0, 297.64), Func(toonbase.localToon.animFSM.request, 'neutral'), Func(toonbase.localToon.setPosHpr, 40.31, 22.0, -0.47, 150.0, 360.0, 0.0), Wait(0.5), Func(self.tutorialTom.reparentTo, render), Func(self.tutorialTom.show), Func(self.tutorialTom.setPosHpr, 40.29, 17.9, -0.47, 11.31, 0.0, 0.07), Func(self.tutorialTom.animFSM.request, 'TeleportIn'), Wait(1.517), Func(self.tutorialTom.animFSM.request, 'neutral'), Func(self.acceptOnce, self.tutorialTom.uniqueName('doneChatPage'), doneChat1), Func(self.tutorialTom.addActive), Func(self.tutorialTom.setLocalPageChat, Localizer.MovieTutorialReward3, None), name='tutorial-reward-3a')
            self.track2 = Sequence(Func(self.acceptOnce, self.tutorialTom.uniqueName('doneChatPage'), doneChat2), Func(self.tutorialTom.setLocalPageChat, Localizer.MovieTutorialReward4, 1), Func(self.tutorialTom.setPlayRate, 1.5, 'right-hand-start'), Func(self.tutorialTom.play, 'right-hand-start'), Wait(self.tutorialTom.getDuration('right-hand-start') / 1.5), Func(self.tutorialTom.loop, 'right-hand'), name='tutorial-reward-3b')
            self.track3 = Parallel(Sequence(Func(self.tutorialTom.setPlayRate, -1.8, 'right-hand-start'), Func(self.tutorialTom.play, 'right-hand-start'), Wait(self.tutorialTom.getDuration('right-hand-start') / 1.8), Func(self.tutorialTom.animFSM.request, 'neutral'), name='tutorial-reward-3ca'), Sequence(Wait(0.5), Func(self.tutorialTom.setChatAbsolute, Localizer.MovieTutorialReward5, CFSpeech | CFTimeout), Wait(1.0), Func(self.tutorialTom.animFSM.request, 'TeleportOut'), Wait(self.tutorialTom.getDuration('teleport')), Wait(1.0), Func(self.playTutorialReward_4, 0), name='tutorial-reward-3cb'), name='tutorial-reward-3c')
            self.track1.start()
        else:
            self.playTutorialReward_4(0)
        return
        return
Пример #10
0
 def load(self):
     SafeZoneLoader.SafeZoneLoader.load(self)
     self.seagullSound = base.loadSfx('phase_6/audio/sfx/SZ_DD_Seagull.mp3')
     self.underwaterSound = base.loadSfx(
         'phase_4/audio/sfx/AV_ambient_water.mp3')
     self.swimSound = base.loadSfx(
         'phase_4/audio/sfx/AV_swim_single_stroke.mp3')
     self.submergeSound = base.loadSfx(
         'phase_5.5/audio/sfx/AV_jump_in_water.mp3')
     water = self.geom.find('**/water')
     water.setTransparency(1)
     water.setColor(1, 1, 1, 0.8)
     boat = self.geom.find('**/donalds_boat')
     if boat.isEmpty():
         self.notify.error('Boat not found')
     else:
         toonbase.tcr.token2nodePath[ToontownGlobals.SPDonaldsBoat] = boat
         wheel = boat.find('**/wheel')
         if wheel.isEmpty():
             self.notify.warning('Wheel not found')
         else:
             wheel.hide()
         boat.stash()
     dna = AvatarDNA.AvatarDNA()
     dna.newChar('dw')
     self.donald = Char.Char()
     self.donald.setDNA(dna)
     self.dockSound = base.loadSfx('phase_6/audio/sfx/SZ_DD_dockcreak.mp3')
     self.foghornSound = base.loadSfx('phase_5/audio/sfx/SZ_DD_foghorn.mp3')
     self.bellSound = base.loadSfx('phase_6/audio/sfx/SZ_DD_shipbell.mp3')
     self.waterSound = base.loadSfx('phase_6/audio/sfx/SZ_DD_waterlap.mp3')
Пример #11
0
    def addSuitHead(self, panel, suitName):
        panelIndex = self.panels.index(panel)
        shadow = panel.attachNewNode('shadow')
        shadowModel = self.shadowModels[panelIndex]
        shadowModel.copyTo(shadow)
        coords = SHADOW_SCALE_POS[panelIndex]
        shadow.setScale(coords[0])
        shadow.setPos(coords[1], coords[2], coords[3])
        panel.shadow = shadow
        suitDNA = AvatarDNA.AvatarDNA()
        suitDNA.newSuit(suitName)
        suit = Suit.Suit()
        suit.setDNA(suitDNA)
        headParts = suit.getHeadParts()
        head = panel.attachNewNode('head')
        for part in headParts:
            copyPart = part.copyTo(head)
            copyPart.setDepthTest(1)
            copyPart.setDepthWrite(1)

        suit.delete()
        suit = None
        p1 = Point3()
        p2 = Point3()
        head.calcTightBounds(p1, p2)
        d = p2 - p1
        biggest = max(d[0], d[2])
        column = panelIndex % AvatarDNA.suitsPerDept
        s = (0.2 + column / 100.0) / biggest
        pos = -0.14 + (AvatarDNA.suitsPerDept - column - 1) / 135.0
        head.setPosHprScale(0, 10.0, pos, 180, 0, 0, s, s, s)
        panel.head = head
        return
Пример #12
0
 def _RoguesGallery__makeSuit(self, dept, type, name=None):
     dna = AvatarDNA.AvatarDNA()
     if name != None:
         dna.newSuit(name)
     else:
         dna.newSuitRandom(type + 1, dept)
     suit = Suit.Suit()
     suit.setStyle(dna)
     suit.generateSuit()
     suit.pose('neutral', 30)
     ll = Point3()
     ur = Point3()
     suit.update()
     suit.calcTightBounds(ll, ur)
     suitWidth = ur[0] - ll[0]
     suitDepth = ur[1] - ll[1]
     suitHeight = ur[2] - ll[2]
     self.rowWidth += suitWidth + suitDepth
     self.rowHeight = max(self.rowHeight, suitHeight)
     suit.reparentTo(self.gallery)
     suit.setHpr(180.0, 0.0, 0.0)
     profile = Suit.Suit()
     profile.setStyle(dna)
     profile.generateSuit()
     profile.pose('neutral', 30)
     profile.reparentTo(self.gallery)
     profile.setHpr(90.0, 0.0, 0.0)
     self.suitRow.append((type, suitWidth, suit, suitDepth, profile))
     self.actors.append(suit)
     self.actors.append(profile)
Пример #13
0
 def popupChangeClothesGUI(self, task):
     self.notify.debug('popupChangeClothesGUI')
     self.purchaseDoneEvent = self.uniqueName('purchaseDone')
     self.swapEvent = self.uniqueName('swap')
     self.cancelEvent = self.uniqueName('cancel')
     self.accept(self.purchaseDoneEvent, self.__proceedToCheckout)
     self.accept(self.swapEvent, self.__handleSwap)
     self.accept(self.cancelEvent, self.__handleCancel)
     self.deleteEvent = self.uniqueName('delete')
     if self.isOwner:
         self.accept(self.deleteEvent, self.__handleDelete)
     self.closetGUI = ClosetGUI.ClosetGUI(self.isOwner,
                                          self.purchaseDoneEvent,
                                          self.cancelEvent, self.swapEvent,
                                          self.deleteEvent, self.topList,
                                          self.botList)
     self.closetGUI.load()
     if self.gender != self.ownerGender:
         self.closetGUI.setGender(self.ownerGender)
     self.closetGUI.enter(toonbase.localToon)
     self.closetGUI.showButtons()
     if toonbase.localToon.getHeight() > 3.5:
         self.closetGUI.topLButton.setZ(0.1)
         self.closetGUI.topRButton.setZ(0.1)
         self.closetGUI.bottomLButton.setZ(-0.3)
         self.closetGUI.bottomRButton.setZ(-0.3)
     else:
         self.closetGUI.topLButton.setZ(0)
         self.closetGUI.topRButton.setZ(0)
         self.closetGUI.bottomLButton.setZ(-0.4)
         self.closetGUI.bottomRButton.setZ(-0.4)
     style = self.av.getStyle()
     self.oldStyle = AvatarDNA.AvatarDNA()
     self.oldStyle.makeFromNetString(style.makeNetString())
     return Task.done
Пример #14
0
 def setDNAString(self, dnaString):
     if not self.dna:
         if self.notify.getDebug():
             self.notify.debug('setting dna string for %d...' % self.getDoId())
         self.dna = AvatarDNA.AvatarDNA()
         self.dna.makeFromNetString(dnaString)
         self.setDNA(self.dna)
     return None
     return
Пример #15
0
 def createSuit(self):
     self.suit = Suit.Suit()
     suitDNA = AvatarDNA.AvatarDNA()
     suitDNA.newSuit('f')
     self.suit.setDNA(suitDNA)
     self.suit.loop('neutral')
     self.suit.setPosHpr(-20, 8, 0, 0, 0, 0)
     self.suit.reparentTo(self.interior)
     self.suitWalkTrack = Sequence(self.suit.hprInterval(0.1, Vec3(0, 0, 0)), Func(self.suit.loop, 'walk'), self.suit.posInterval(2, Point3(-20, 20, 0)), Func(self.suit.loop, 'neutral'), Wait(1.0), self.suit.hprInterval(0.1, Vec3(180, 0, 0)), Func(self.suit.loop, 'walk'), self.suit.posInterval(2, Point3(-20, 10, 0)), Func(self.suit.loop, 'neutral'), Wait(1.0))
     self.suitWalkTrack.loop()
 def __init__(self, cr, name, dnaName):
     try:
         self.DistributedCCharBase_initialized
     except:
         self.DistributedCCharBase_initialized = 1
         DistributedChar.DistributedChar.__init__(self, cr)
         dna = AvatarDNA.AvatarDNA()
         dna.newChar(dnaName)
         self.setDNA(dna)
         self.setName(name)
         self.__initCollisions()
Пример #17
0
 def createNpcToonHead(self, toNpcId):
     npcInfo = NPCToons.NPCToonDict[toNpcId]
     dnaList = npcInfo[2]
     gender = npcInfo[3]
     if dnaList == 'r':
         dnaList = NPCToons.getRandomDNA(toNpcId, gender)
     dna = AvatarDNA.AvatarDNA()
     dna.newToonFromProperties(*dnaList)
     head = ToonHead.ToonHead()
     head.setupHead(dna, forGui=1)
     self.fitGeometry(head, fFlip=1)
     return head
    def parseLoadChar(self, line):
        (token, name, charType) = line
        char = Char.Char()
        dna = AvatarDNA.AvatarDNA()
        dna.newChar(charType)
        char.setDNA(dna)
        if charType == 'mk' or charType == 'mn':
            char.startEarTask()

        char.nametag.manage(toonbase.marginManager)
        char.addActive()
        char.hideName()
        self.setVar(name, char)
Пример #19
0
 def __init__(self, serialNum, maze, randomNumGen, cellWalkPeriod,
              difficulty):
     self.serialNum = serialNum
     self.maze = maze
     self.rng = RandomNumGen.RandomNumGen(randomNumGen)
     self.difficulty = difficulty
     self.suit = Suit.Suit()
     d = AvatarDNA.AvatarDNA()
     d.newSuit('f')
     self.suit.setDNA(d)
     self.ticPeriod = int(cellWalkPeriod)
     self.cellWalkDuration = float(self.ticPeriod) / float(
         MazeGameGlobals.SUIT_TIC_FREQ)
     self.turnDuration = 0.6 * self.cellWalkDuration
 def parseLoadClassicChar(self, line):
     (token, name) = line
     char = Char.Char()
     dna = AvatarDNA.AvatarDNA()
     if self.toon.getStyle().gender == 'm':
         charType = 'mk'
     else:
         charType = 'mn'
     dna.newChar(charType)
     char.setDNA(dna)
     char.startEarTask()
     char.nametag.manage(toonbase.marginManager)
     char.addActive()
     char.hideName()
     self.setVar(name, char)
Пример #21
0
 def inviteeFriendQuery(self, inviterId, inviterName, inviterDna, context):
     dna = AvatarDNA.AvatarDNA()
     dna.makeFromNetString(inviterDna)
     self.notify.debug('Client: inviteeFriendQuery(%d, %s, dna, %d)' %
                       (inviterId, inviterName, context))
     if inviterId in toonbase.localToon.ignoreList:
         self.up_inviteeFriendConsidering(4, context)
         return
     if not toonbase.localToon.acceptingNewFriends:
         self.up_inviteeFriendConsidering(6, context)
         return
     self.up_inviteeFriendConsidering(self.__available, context)
     if self.__available:
         messenger.send('friendInvitation',
                        [inviterId, inviterName, dna, context])
Пример #22
0
    def getQuestIntervalList(self, toon, deathList, toonList=[]):
        avQuests = copy.deepcopy(toon.quests)
        avId = toon.getDoId()
        changed = 0
        tickDelay = 0.5
        intervalList = []
        cogList = []
        for i in range(0, len(deathList), 2):
            cogIndex = deathList[i]
            cogLevel = deathList[i + 1]
            cogType = AvatarDNA.suitHeadTypes[cogIndex]
            cogTrack = AvatarDNA.getSuitDept(cogType)
            cogList.append({
                'type': cogType,
                'level': cogLevel,
                'track': cogTrack,
                'activeToons': [avId]
            })

        try:
            zoneId = toonbase.tcr.playGame.getPlace().getZoneId()
        except:
            zoneId = 0
        else:
            for i in range(len(avQuests)):
                questDesc = avQuests[i]
                questId, npcId, toNpcId, rewardId, toonProgress = questDesc
                quest = Quests.getQuest(questId)
                questString = quest.getString()
                progressString = quest.getProgressString(toon, questDesc)
                questLabel = self.questLabelList[i]
                for cogDict in cogList:
                    if quest.doesCogCount(avId, cogDict, zoneId, toonList):
                        questDesc[4] += 1
                        changed = 1
                        progressString = quest.getProgressString(
                            toon, questDesc)
                        str = '%s : %s' % (questString, progressString)
                        if quest.getCompletionStatus(
                                toon, questDesc) == Quests.COMPLETE:
                            intervalList.append(
                                Func(questLabel.setProp, 'text_fg',
                                     (0, 0.3, 0, 1)))
                        intervalList.append(
                            Func(questLabel.setProp, 'text', str))
                        intervalList.append(Wait(tickDelay))

        return intervalList
Пример #23
0
 def createSuitHead(self, suitName):
     suitDNA = AvatarDNA.AvatarDNA()
     suitDNA.newSuit(suitName)
     suit = Suit.Suit()
     suit.setDNA(suitDNA)
     headParts = suit.getHeadParts()
     head = hidden.attachNewNode('head')
     for part in headParts:
         copyPart = part.copyTo(head)
         copyPart.setDepthTest(1)
         copyPart.setDepthWrite(1)
     
     self.fitGeometry(head, fFlip = 1)
     suit.delete()
     suit = None
     return head
Пример #24
0
 def setupSuitBuilding(self, nodePath):
     dnaStore = self.cr.playGame.dnaStore
     level = int(self.difficulty / 2) + 1
     suitNP = dnaStore.findNode('suit_landmark_' + chr(self.track) +
                                str(level))
     zoneId = dnaStore.getZoneFromBlockNumber(self.block)
     newParentNP = toonbase.tcr.playGame.hood.loader.zoneDict[zoneId]
     suitBuildingNP = suitNP.copyTo(newParentNP)
     buildingTitle = dnaStore.getTitleFromBlockNumber(self.block)
     if buildingTitle:
         buildingTitle += ', Inc.'
     else:
         buildingTitle = 'COGS, Inc.'
     buildingTitle += '\n%s' % AvatarDNA.getDeptFullname(chr(self.track))
     textNode = TextNode('sign')
     textNode.freeze()
     textNode.setTextColor(1.0, 1.0, 1.0, 1.0)
     textNode.setFont(ToontownGlobals.getSuitFont())
     textNode.setAlign(TextNode.ACenter)
     textNode.setWordwrap(17.0)
     textNode.setText(buildingTitle)
     textHeight = textNode.getHeight()
     zScale = (textHeight + 2) / 3.0
     signOrigin = suitBuildingNP.find('**/sign_origin;+s')
     backgroundNP = loader.loadModel('phase_5/models/modules/suit_sign')
     backgroundNP.reparentTo(signOrigin)
     backgroundNP.setPosHprScale(0.0, 0.0,
                                 textHeight * 0.80000000000000004 / zScale,
                                 0.0, 0.0, 0.0, 8.0, 8.0, 8.0 * zScale)
     backgroundNP.node().setEffect(DecalEffect.make())
     signTextNodePath = backgroundNP.attachNewNode(textNode.generate())
     signTextNodePath.setPosHprScale(
         0.0, 0.0,
         -0.20999999999999999 + textHeight * 0.10000000000000001 / zScale,
         0.0, 0.0, 0.0, 0.10000000000000001, 0.10000000000000001,
         0.10000000000000001 / zScale)
     signTextNodePath.setColor(1.0, 1.0, 1.0, 1.0)
     frontNP = suitBuildingNP.find('**/*_front/+GeomNode;+s')
     backgroundNP.wrtReparentTo(frontNP)
     frontNP.node().setEffect(DecalEffect.make())
     suitBuildingNP.setName('sb' + str(self.block) + ':_landmark__DNARoot')
     suitBuildingNP.setPosHprScale(nodePath, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                                   1.0, 1.0, 1.0)
     suitBuildingNP.flattenMedium()
     self.loadElevator(suitBuildingNP)
     return suitBuildingNP
Пример #25
0
 def resetCloset(self):
     self.ignoreAll()
     taskMgr.remove(self.uniqueName('popupChangeClothesGUI'))
     taskMgr.remove(self.uniqueName('lerpCamera'))
     taskMgr.remove(self.uniqueName('lerpToon'))
     if self.closetGUI:
         self.closetGUI.hideButtons()
         self.closetGUI.exit()
         self.closetGUI.unload()
         self.closetGUI = None
         del self.av
     self.av = toonbase.localToon
     style = self.av.getStyle()
     self.oldStyle = AvatarDNA.AvatarDNA()
     self.oldStyle.makeFromNetString(style.makeNetString())
     self.topDeleted = 0
     self.bottomDeleted = 0
     return Task.done
     return
Пример #26
0
    def __handleDelete(self, t_or_b):
        if t_or_b == ClosetGlobals.SHIRT:
            itemList = self.closetGUI.tops
            trashIndex = self.closetGUI.topChoice
            swapFunc = self.closetGUI.swapTop
            removeFunc = self.closetGUI.removeTop
            self.topDeleted = self.topDeleted | 1

            def setItemChoice(i):
                self.closetGUI.topChoice = i

        else:
            itemList = self.closetGUI.bottoms
            trashIndex = self.closetGUI.bottomChoice
            swapFunc = self.closetGUI.swapBottom
            removeFunc = self.closetGUI.removeBottom
            self.bottomDeleted = self.bottomDeleted | 1

            def setItemChoice(i):
                self.closetGUI.bottomChoice = i

        if len(itemList) > 1:
            trashDNA = AvatarDNA.AvatarDNA()
            trashItem = self.av.getStyle().makeNetString()
            trashDNA.makeFromNetString(trashItem)
            if trashIndex == 0:
                swapFunc(1)
            else:
                swapFunc(-1)
            removeFunc(trashIndex)
            self.sendUpdate('removeItem', [trashItem, t_or_b])
            swapFunc(0)
            self.closetGUI.updateTrashButtons()
        else:
            self.notify.warning(
                "cant delete this item(type = %s), since we don't have a replacement"
                % t_or_b)
Пример #27
0
def getRandomDNA(seed, gender):
    randomDNA = AvatarDNA.AvatarDNA()
    randomDNA.newToonRandom(seed, gender)
    return randomDNA.asTuple()
Пример #28
0
 def setDNAString(self, dnaString):
     newDNA = AvatarDNA.AvatarDNA()
     newDNA.makeFromNetString(dnaString)
     self.setDNA(newDNA)
Пример #29
0
 def setMovie(self, mode, npcId, avId, timestamp):
     timeStamp = ClockDelta.globalClockDelta.localElapsedTime(timestamp)
     self.remain = NPCToons.CLERK_COUNTDOWN_TIME - timeStamp
     self.npcId = npcId
     self.isLocalToon = avId == toonbase.localToon.doId
     if mode == NPCToons.PURCHASE_MOVIE_CLEAR:
         return
     if mode == NPCToons.PURCHASE_MOVIE_TIMEOUT:
         taskMgr.remove(self.uniqueName('lerpCamera'))
         if self.isLocalToon:
             self.ignore(self.purchaseDoneEvent)
             self.ignore(self.swapEvent)
             if self.popupInfo:
                 self.popupInfo.reparentTo(hidden)
         if self.clothesGUI:
             self.clothesGUI.resetClothes(self.oldStyle)
             self.__handlePurchaseDone(timeout=1)
         self.setChatAbsolute(Localizer.STOREOWNER_TOOKTOOLONG,
                              CFSpeech | CFTimeout)
         self.resetTailor()
     else:
         if mode == NPCToons.PURCHASE_MOVIE_START or mode == NPCToons.PURCHASE_MOVIE_START_BROWSE or mode == NPCToons.PURCHASE_MOVIE_START_NOROOM:
             if mode == NPCToons.PURCHASE_MOVIE_START:
                 self.browsing = 0
                 self.roomAvailable = 1
             else:
                 if mode == NPCToons.PURCHASE_MOVIE_START_BROWSE:
                     self.browsing = 1
                     self.roomAvailable = 1
                 else:
                     if mode == NPCToons.PURCHASE_MOVIE_START_NOROOM:
                         self.browsing = 0
                         self.roomAvailable = 0
             self.av = toonbase.tcr.doId2do.get(avId)
             style = self.av.getStyle()
             self.oldStyle = AvatarDNA.AvatarDNA()
             self.oldStyle.makeFromNetString(style.makeNetString())
             if self.av is None:
                 self.notify.warning('Avatar %d not found in doId' % avId)
                 return
             else:
                 self.accept(self.av.uniqueName('disable'),
                             self.__handleUnexpectedExit)
             self.setupAvatars(self.av)
             if self.isLocalToon:
                 camera.wrtReparentTo(render)
                 camera.lerpPosHpr(-5,
                                   9,
                                   self.getHeight() - 0.5,
                                   -150,
                                   -2,
                                   0,
                                   1,
                                   other=self,
                                   blendType='easeOut',
                                   task=self.uniqueName('lerpCamera'))
             if self.browsing == 0:
                 if self.roomAvailable == 0:
                     self.setChatAbsolute(Localizer.STOREOWNER_NOROOM,
                                          CFSpeech | CFTimeout)
                 else:
                     self.setChatAbsolute(Localizer.STOREOWNER_GREETING,
                                          CFSpeech | CFTimeout)
             else:
                 self.setChatAbsolute(Localizer.STOREOWNER_BROWSING,
                                      CFSpeech | CFTimeout)
             if self.isLocalToon:
                 taskMgr.doMethodLater(3.0, self.popupPurchaseGUI,
                                       self.uniqueName('popupPurchaseGUI'))
         else:
             if mode == NPCToons.PURCHASE_MOVIE_COMPLETE:
                 self.setChatAbsolute(Localizer.STOREOWNER_GOODBYE,
                                      CFSpeech | CFTimeout)
                 self.resetTailor()
             else:
                 if mode == NPCToons.PURCHASE_MOVIE_NO_MONEY:
                     self.notify.warning(
                         'PURCHASE_MOVIE_NO_MONEY should not be called')
                     self.resetTailor()
     return
     return
Пример #30
0
 def getStyleDept(self):
     if self.dna:
         return AvatarDNA.getDeptFullname(self.dna.dept)
     else:
         self.notify.error('called getStyleDept() before dna was set!')
         return 'unknown'
Пример #31
0
 def getStyleDept(self):
     if self.dna:
         return AvatarDNA.getDeptFullname(self.dna.dept)
     else:
         self.notify.error('called getStyleDept() before dna was set!')
         return 'unknown'
Пример #32
0
 def __init__(self, avatar):
     if AvatarPanel.currentAvatarPanel:
         AvatarPanel.currentAvatarPanel.cleanup()
     
     AvatarPanel.currentAvatarPanel = self
     self.friendsListShown = FriendsListPanel.isFriendsListShown()
     FriendsListPanel.hideFriendsList()
     self.laffMeter = None
     self.avName = avatar.getName()
     if isinstance(avatar, DistributedObject.DistributedObject) or isinstance(avatar, FriendHandle.FriendHandle):
         self.avId = avatar.doId
         self.avDisableName = avatar.uniqueName('disable')
         self.avGenerateName = avatar.uniqueName('generate')
         self.avHpChangeName = avatar.uniqueName('hpChange')
         if toonbase.tcr.doId2do.has_key(self.avId):
             avatar = toonbase.tcr.doId2do[self.avId]
         
     else:
         self.avDisableName = None
         self.avGenerateName = None
         self.avHpChangeName = None
         self.avId = None
     import Toon
     if not isinstance(avatar, Toon.Toon):
         pass
     self.isToon = isinstance(avatar, FriendHandle.FriendHandle)
     wantsLaffMeter = isinstance(avatar, Toon.Toon)
     toonbase.localToon.obscureFriendsListButton(1)
     if self.isToon:
         gui = loader.loadModelOnce('phase_3.5/models/gui/avatar_panel_gui')
         self.frame = DirectFrame(image = gui.find('**/avatar_panel'), relief = None, pos = (1.1000000000000001, 100, 0.52500000000000002))
     else:
         gui = loader.loadModelOnce('phase_3.5/models/gui/suit_detail_panel')
         self.frame = DirectFrame(geom = gui.find('**/avatar_panel'), geom_scale = 0.20999999999999999, geom_pos = (0, 0, 0.02), relief = None, pos = (1.1000000000000001, 100, 0.52500000000000002))
     disabledImageColor = Vec4(1, 1, 1, 0.40000000000000002)
     text0Color = Vec4(1, 1, 1, 1)
     text1Color = Vec4(0.5, 1, 0.5, 1)
     text2Color = Vec4(1, 1, 0.5, 1)
     text3Color = Vec4(1, 1, 1, 0.20000000000000001)
     if self.isToon:
         self.head = self.frame.attachNewNode('head')
         self.head.setPos(0.02, 0, 0.28999999999999998)
         self.headModel = ToonHead.ToonHead()
         self.headModel.setupHead(avatar.style, forGui = 1)
         self.headModel.fitAndCenterHead(0.17499999999999999, forGui = 1)
         self.headModel.reparentTo(self.head)
         self.headModel.startBlink()
         self.headModel.startLookAround()
         self.healthText = DirectLabel(parent = self.frame, text = '', pos = (0.059999999999999998, 0, 0.16500000000000001), text_pos = (0, 0), text_scale = 0.050000000000000003)
         self.healthText.hide()
     else:
         self.head = self.frame.attachNewNode('head')
         for part in avatar.headParts:
             copyPart = part.copyTo(self.head)
             copyPart.setDepthTest(1)
             copyPart.setDepthWrite(1)
         
         p1 = Point3()
         p2 = Point3()
         self.head.calcTightBounds(p1, p2)
         d = p2 - p1
         biggest = max(d[0], d[1], d[2])
         s = 0.29999999999999999 / biggest
         self.head.setPosHprScale(0, 0, 0, 180, 0, 0, s, s, s)
     if self.isToon:
         self.nameLabel = DirectLabel(parent = self.frame, pos = (0.012500000000000001, 0, 0.38500000000000001), relief = None, text = self.avName, text_font = avatar.getFont(), text_fg = Vec4(0, 0, 0, 1), text_pos = (0, 0), text_scale = 0.047, text_wordwrap = 7.5, text_shadow = (1, 1, 1, 1))
         self.closeButton = DirectButton(parent = self.frame, image = (gui.find('**/CloseBtn_UP'), gui.find('**/CloseBtn_DN'), gui.find('**/CloseBtn_Rllvr')), relief = None, pos = (0.15764400000000001, 0, -0.37916699999999998), command = self._AvatarPanel__handleClose)
         self.friendButton = DirectButton(parent = self.frame, image = (gui.find('**/Frnds_Btn_UP'), gui.find('**/Frnds_Btn_DN'), gui.find('**/Frnds_Btn_RLVR'), gui.find('**/Frnds_Btn_UP')), image3_color = disabledImageColor, relief = None, text = Localizer.AvatarPanelFriends, text_scale = 0.059999999999999998, pos = (-0.10299999999999999, 0, 0.096000000000000002), text0_fg = text0Color, text1_fg = text1Color, text2_fg = text2Color, text3_fg = text3Color, text_pos = (0.059999999999999998, -0.02), text_align = TextNode.ALeft, command = self._AvatarPanel__handleFriend)
         self.whisperButton = DirectButton(parent = self.frame, image = (gui.find('**/ChtBx_ChtBtn_UP'), gui.find('**/ChtBx_ChtBtn_DN'), gui.find('**/ChtBx_ChtBtn_RLVR'), gui.find('**/ChtBx_ChtBtn_UP')), image3_color = disabledImageColor, relief = None, pos = (-0.10299999999999999, 0, -0.090499999999999997), text = Localizer.AvatarPanelWhisper, text0_fg = text0Color, text1_fg = text1Color, text2_fg = text2Color, text3_fg = text3Color, text_scale = 0.059999999999999998, text_pos = (0.059999999999999998, -0.02), text_align = TextNode.ALeft, command = self._AvatarPanel__handleWhisper)
         self.secretsButton = DirectButton(parent = self.frame, image = (gui.find('**/ChtBx_ChtBtn_UP'), gui.find('**/ChtBx_ChtBtn_DN'), gui.find('**/ChtBx_ChtBtn_RLVR'), gui.find('**/ChtBx_ChtBtn_UP')), image3_color = disabledImageColor, relief = None, pos = (-0.10299999999999999, 0, -0.1875), text = Localizer.AvatarPanelSecrets, text0_fg = text0Color, text1_fg = text1Color, text2_fg = text2Color, text3_fg = text3Color, text_scale = 0.059999999999999998, text_pos = (0.059999999999999998, -0.02), text_align = TextNode.ALeft, command = self._AvatarPanel__handleSecrets)
         self.goToButton = DirectButton(parent = self.frame, image = (gui.find('**/Go2_Btn_UP'), gui.find('**/Go2_Btn_DN'), gui.find('**/Go2_Btn_RLVR'), gui.find('**/Go2_Btn_UP')), image3_color = disabledImageColor, relief = None, pos = (-0.10299999999999999, 0, 0.0029399999999999999), text = Localizer.AvatarPanelGoTo, text0_fg = text0Color, text1_fg = text1Color, text2_fg = text2Color, text3_fg = text3Color, text_scale = 0.059999999999999998, text_pos = (0.059999999999999998, -0.02), text_align = TextNode.ALeft, command = self._AvatarPanel__handleGoto)
         self.ignoreButton = DirectButton(parent = self.frame, image = (gui.find('**/Ignore_Btn_UP'), gui.find('**/Ignore_Btn_DN'), gui.find('**/Ignore_Btn_RLVR'), gui.find('**/Ignore_Btn_UP')), image3_color = disabledImageColor, relief = None, pos = (-0.103697, 0, -0.27487499999999998), text = Localizer.AvatarPanelIgnore, text0_fg = text0Color, text1_fg = text1Color, text2_fg = text2Color, text3_fg = text3Color, text_scale = 0.059999999999999998, text_pos = (0.059999999999999998, -0.02), text_align = TextNode.ALeft, command = self._AvatarPanel__handleIgnore)
         self.ignoreButton.hide()
         self.detailButton = DirectButton(parent = self.frame, image = (gui.find('**/ChtBx_BackBtn_UP'), gui.find('**/ChtBx_BackBtn_DN'), gui.find('**/ChtBx_BackBtn_Rllvr')), relief = None, pos = (-0.133773, 0, -0.38713199999999998), command = self._AvatarPanel__handleDetails)
     else:
         self.nameLabel = DirectLabel(parent = self.frame, pos = (0.012500000000000001, 0, 0.35999999999999999), relief = None, text = self.avName, text_font = avatar.getFont(), text_fg = Vec4(0, 0, 0, 1), text_pos = (0, 0), text_scale = 0.047, text_wordwrap = 7.5, text_shadow = (1, 1, 1, 1))
         level = avatar.getActualLevel()
         dept = AvatarDNA.getSuitDeptFullname(avatar.dna.name)
         self.levelLabel = DirectLabel(parent = self.frame, pos = (0, 0, -0.10000000000000001), relief = None, text = Localizer.AvatarPanelCogLevel % level, text_font = avatar.getFont(), text_align = TextNode.ACenter, text_fg = Vec4(0, 0, 0, 1), text_pos = (0, 0), text_scale = 0.050000000000000003, text_wordwrap = 8.0)
         corpIcon = avatar.corpMedallion.copyTo(hidden)
         corpIcon.iPosHprScale()
         self.corpIcon = DirectLabel(parent = self.frame, geom = corpIcon, geom_scale = 0.13, pos = (0, 0, -0.17499999999999999), relief = None)
         corpIcon.removeNode()
         self.deptLabel = DirectLabel(parent = self.frame, pos = (0, 0, -0.28000000000000003), relief = None, text = dept, text_font = avatar.getFont(), text_align = TextNode.ACenter, text_fg = Vec4(0, 0, 0, 1), text_pos = (0, 0), text_scale = 0.050000000000000003, text_wordwrap = 8.0)
         self.closeButton = DirectButton(parent = self.frame, relief = None, pos = (0.0, 0, -0.35999999999999999), text = Localizer.AvatarPanelCogDetailClose, text_font = avatar.getFont(), text0_fg = Vec4(0, 0, 0, 1), text1_fg = Vec4(0.5, 0, 0, 1), text2_fg = Vec4(1, 0, 0, 1), text_pos = (0, 0), text_scale = 0.050000000000000003, command = self._AvatarPanel__handleClose)
     gui.removeNode()
     if wantsLaffMeter:
         self._AvatarPanel__makeLaffMeter(avatar)
         self._AvatarPanel__updateHp(avatar.hp, avatar.maxHp)
         self.healthText.show()
         self.laffMeter.show()
     
     menuX = -0.050000000000000003
     menuScale = 0.064000000000000001
     if self.avDisableName:
         self.accept(self.avDisableName, self._AvatarPanel__handleDisableAvatar)
     
     if self.isToon:
         if self.avGenerateName:
             self.accept(self.avGenerateName, self._AvatarPanel__handleGenerateAvatar)
         
         if self.avHpChangeName:
             self.accept(self.avHpChangeName, self._AvatarPanel__updateHp)
         
     
     self.accept('updateLaffMeter', self._AvatarPanel__updateLaffMeter)
     self.frame.show()
     messenger.send('avPanelDone')
    def load(self):
        self.notify.debug('load')
        DistributedMinigame.load(self)
        self.timer = ToontownTimer.ToontownTimer()
        self.timer.posInTopRightCorner()
        self.timer.hide()
        self.room = loader.loadModel('phase_4/models/minigames/matching_room')
        self.buttonSounds = []
        for soundName in self.ButtonSoundNames:
            self.buttonSounds.append(base.loadSfx(soundName))

        self.correctSound = base.loadSfx('phase_4/audio/sfx/MG_pos_buzzer.wav')
        self.incorrectSound = base.loadSfx(
            'phase_4/audio/sfx/MG_neg_buzzer.wav')
        self.perfectSound = base.loadSfx('phase_4/audio/sfx/MG_win.mp3')
        self.fallSound = base.loadSfx('phase_4/audio/sfx/Mg_Tag_A.mp3')
        self.music = base.loadMusic(self.bgm)
        self.waitingText = DirectLabel(text=self.strPleaseWait,
                                       text_fg=(0.9, 0.9, 0.9, 1.0),
                                       frameColor=(1, 1, 1, 0),
                                       text_font=ToontownGlobals.getSignFont(),
                                       pos=(0, 0, -0.78),
                                       scale=0.12)
        self.roundText = DirectLabel(text='Round 1!',
                                     text_fg=self.normalTextColor,
                                     frameColor=(1, 1, 1, 0),
                                     text_font=ToontownGlobals.getSignFont(),
                                     pos=(0.014, 0, -0.84),
                                     scale=0.12)
        self.roundText.hide()
        self.waitingText.hide()
        matchingGameGui = loader.loadModel(
            'phase_3.5/models/gui/matching_game_gui')
        minnieArrow = matchingGameGui.find('**/minnieArrow')
        minnieX = matchingGameGui.find('**/minnieX')
        minnieCircle = matchingGameGui.find('**/minnieCircle')
        self.arrows = [None] * 5
        for x in range(0, 5):
            self.arrows[x] = minnieArrow.copyTo(hidden)
            self.arrows[x].hide()

        self.xs = [None] * 5
        for x in range(0, 5):
            self.xs[x] = minnieX.copyTo(hidden)
            self.xs[x].hide()

        self.statusBalls = []
        self.totalMoves = PatternGameGlobals.INITIAL_ROUND_LENGTH + PatternGameGlobals.ROUND_LENGTH_INCREMENT * (
            PatternGameGlobals.NUM_ROUNDS - 1)
        for x in range(0, 4):
            self.statusBalls.append([None] * self.totalMoves)

        for x in range(0, 4):
            for y in range(0, self.totalMoves):
                self.statusBalls[x][y] = minnieCircle.copyTo(hidden)
                self.statusBalls[x][y].hide()

        minnieArrow.removeNode()
        minnieX.removeNode()
        minnieCircle.removeNode()
        matchingGameGui.removeNode()
        self.minnie = Char.Char()
        m = self.minnie
        dna = AvatarDNA.AvatarDNA()
        dna.newChar('mn')
        m.setDNA(dna)
        m.setName(Localizer.Minnie)
        m.reparentTo(hidden)
        self.backRowHome = Point3(3, 11, 0)
        self.backRowXSpacing = 1.8
        self.frontRowHome = Point3(0, 18, 0)
        self.frontRowXSpacing = 3.0
        self.stdNumDanceStepPingFrames = self.minnie.getNumFrames(
            self.minnieAnimNames[0])
        self.stdNumDanceStepPingPongFrames = self.__numPingPongFrames(
            self.stdNumDanceStepPingFrames)
        self.buttonPressDelayPercent = (self.stdNumDanceStepPingFrames - 1.0
                                        ) / self.stdNumDanceStepPingPongFrames
        self.animPlayRates = []
        animPlayRate = 1.4
        animPlayRateMult = 1.06
        for i in range(PatternGameGlobals.NUM_ROUNDS):
            self.animPlayRates.append(animPlayRate)
            animPlayRate *= animPlayRateMult

        return
Пример #34
0
 def _BodyShop__swapTorso(self, offset):
     gender = self.toon.style.getGender()
     if not (self.clothesPicked):
         length = len(AvatarDNA.toonTorsoTypes[6:])
         torsoOffset = 6
     elif gender == 'm':
         length = len(AvatarDNA.toonTorsoTypes[:3])
         torsoOffset = 0
         if self.dna.armColor not in AvatarDNA.defaultBoyColorList:
             self.dna.armColor = AvatarDNA.defaultBoyColorList[0]
         
         if self.dna.legColor not in AvatarDNA.defaultBoyColorList:
             self.dna.legColor = AvatarDNA.defaultBoyColorList[0]
         
         if self.dna.headColor not in AvatarDNA.defaultBoyColorList:
             self.dna.headColor = AvatarDNA.defaultBoyColorList[0]
         
         if AvatarDNA.isValidBoyShirt(self.toon.style.topTex) == 0:
             pair = random.choice(AvatarDNA.BoyShirts)
             self.toon.style.topTex = pair[0]
             self.toon.style.sleeveTex = pair[1]
         
         clength = len(AvatarDNA.BoyShorts)
         if self.toon.style.botTex >= clength:
             self.toon.style.botTex = whrandom.randint(0, clength - 1)
         
     else:
         length = len(AvatarDNA.toonTorsoTypes[3:6])
         if self.toon.style.torso[1] == 'd':
             torsoOffset = 3
         else:
             torsoOffset = 0
         if self.dna.armColor not in AvatarDNA.defaultGirlColorList:
             self.dna.armColor = AvatarDNA.defaultGirlColorList[0]
         
         if self.dna.legColor not in AvatarDNA.defaultGirlColorList:
             self.dna.legColor = AvatarDNA.defaultGirlColorList[0]
         
         if self.dna.headColor not in AvatarDNA.defaultGirlColorList:
             self.dna.headColor = AvatarDNA.defaultGirlColorList[0]
         
         if AvatarDNA.isValidBoyShirt(self.toon.style.topTex) == 0:
             pair = random.choice(AvatarDNA.GirlShirts)
             self.toon.style.topTex = pair[0]
             self.toon.style.sleeveTex = pair[1]
         
         clength = len(AvatarDNA.GirlBottoms)
         if self.toon.style.botTex >= clength:
             if self.toon.style.torso[1] == 'd':
                 self.toon.style.botTex = AvatarDNA.getRandomGirlBottom(AvatarDNA.SKIRT)
                 torsoOffset = 3
             else:
                 self.toon.style.botTex = AvatarDNA.getRandomGirlBottom(AvatarDNA.SHORTS)
                 torsoOffset = 0
         
     self.torsoChoice = (self.torsoChoice + offset) % length
     self._BodyShop__updateScrollButtons(self.torsoChoice, length, self.torsoStart, self.torsoLButton, self.torsoRButton)
     torso = AvatarDNA.toonTorsoTypes[torsoOffset + self.torsoChoice]
     self.dna.torso = torso
     self.toon.swapToonTorso(torso)
     self.toon.loop('neutral', 0)
     self.toon.swapToonColor(self.dna)