Python quest.Quests类代码示例

    def recoverItems(self, av, suitsKilled, taskZoneId):
        # Get the avatars current quests.
        avQuests = av.getQuests()
        questList = []
        recoveredItems = []
        unrecoveredItems = []
        taskZoneId = ZoneUtil.getBranchZone(taskZoneId)

        # Iterate through the avatars current quests.
        for i in xrange(0, len(avQuests), 5):
            questDesc = avQuests[i : i + 5]
            questClass = Quests.getQuest(questDesc[QuestIdIndex])
            if questClass.getCompletionStatus(av, questDesc) == Quests.INCOMPLETE:
                if isinstance(questClass, Quests.CogQuest):
                    for suit in suitsKilled:
                        if questClass.doesCogCount(av.doId, suit, taskZoneId, suit['activeToons']):
                            questDesc[QuestProgressIndex] += 1
                elif isinstance(questClass, Quests.RecoverItemQuest):
                    if questClass.getHolder() != Quests.AnyFish:
                        for suit in suitsKilled:
                            if questClass.doesCogCount(av.doId, suit, taskZoneId, suit['activeToons']):
                                baseChance = questClass.getPercentChance()
                                amountRemaining = questClass.getNumItems() - questDesc[QuestProgressIndex]
                                chance = Quests.calcRecoverChance(amountRemaining, baseChance)
                                if chance >= baseChance:
                                    questDesc[QuestProgressIndex] += 1
                                    recoveredItems.append(questClass.getItem())
                                else:
                                    unrecoveredItems.append(questClass.getItem())
            questList.append(questDesc)

        av.b_setQuests(questList)
        return (recoveredItems, unrecoveredItems)

    def initQuestFrame(self, toon, avQuests):
        self.endTrackFrame.hide()
        self.gagExpFrame.hide()
        self.newGagFrame.hide()
        self.promotionFrame.hide()
        self.questFrame.show()
        self.itemFrame.hide()
        self.cogPartFrame.hide()
        self.missedItemFrame.hide()
        for i in xrange(ToontownGlobals.MaxQuestCarryLimit):
            questLabel = self.questLabelList[i]
            questLabel['text_fg'] = (0, 0, 0, 1)
            questLabel.hide()

        for i in xrange(len(avQuests)):
            questDesc = avQuests[i]
            questId, npcId, toNpcId, rewardId, toonProgress = questDesc
            quest = Quests.getQuest(questId)
            if quest:
                questString = quest.getString()
                progressString = quest.getProgressString(toon, questDesc)
                rewardString = quest.getRewardString(progressString)
                rewardString = Quests.fillInQuestNames(rewardString, toNpcId=toNpcId)
                completed = quest.getCompletionStatus(toon, questDesc) == Quests.COMPLETE
                questLabel = self.questLabelList[i]
                questLabel.show()
                if base.localAvatar.tutorialAck:
                    questLabel['text'] = rewardString
                    if completed:
                        questLabel['text_fg'] = (0, 0.3, 0, 1)
                else:
                    questLabel['text'] = questString + ' :'

    def toonCaughtFishingItem(self, av):
        # Get the avatars current quests.
        avQuests = av.getQuests()
        fishingItem = -1
        questList = []

        # Iterate through their current quests.
        for i in xrange(0, len(avQuests), 5):
            questDesc = avQuests[i : i + 5]
            questClass = Quests.getQuest(questDesc[QuestIdIndex])
            if fishingItem != -1:
                questList.append(questDesc)
                continue
            if isinstance(questClass, Quests.RecoverItemQuest):
                if not hasattr(questClass, 'getItem'):
                    questList.append(questDesc)
                    continue
                if questClass.getHolder() == Quests.AnyFish:
                    if not questClass.getCompletionStatus(av, questDesc) == Quests.COMPLETE:
                        baseChance = questClass.getPercentChance()
                        amountRemaining = questClass.getNumItems() - questDesc[QuestProgressIndex]
                        chance = Quests.calcRecoverChance(amountRemaining, baseChance)
                        if chance >= baseChance:
                            questDesc[QuestProgressIndex] += 1
                            fishingItem = questClass.getItem()
            questList.append(questDesc)

        av.b_setQuests(questList)
        return fishingItem

 def trolleyLeft(self):
     numPlayers = self.countFullSeats()
     if numPlayers > 0:
         newbieIds = []
         for avId in self.seats:
             if avId:
                 toon = self.air.doId2do.get(avId)
                 if toon:
                     if Quests.avatarHasTrolleyQuest(toon):
                         if not Quests.avatarHasCompletedTrolleyQuest(toon):
                             newbieIds.append(avId)
         playerArray = []
         for i in self.seats:
             if i not in [None, 0]:
                 playerArray.append(i)
         mgDict = MinigameCreatorAI.createMinigame(
             self.air, playerArray, self.zoneId, newbieIds=newbieIds)
         minigameZone = mgDict['minigameZone']
         minigameId = mgDict['minigameId']
         for seatIndex in xrange(len(self.seats)):
             avId = self.seats[seatIndex]
             if avId:
                 self.sendUpdateToAvatarId(avId, 'setMinigameZone', [minigameZone, minigameId])
                 self.clearFullNow(seatIndex)
     else:
         self.notify.warning('The trolley left, but was empty.')
     self.enter()

 def avatarChoseQuest(self, avId, npc, questId, rewardId, building):
     toon = self.air.doId2do.get(avId)
     if not toon:
         return
     fromNpc = Quests.getQuestFromNpcId(questId)
     toNpc = Quests.getQuestToNpcId(questId)
     toon.addQuest([questId, fromNpc, toNpc, rewardId, 0], 0,
                     recordHistory = 0)
     npc.assignQuest(avId, questId, rewardId, toNpc)
     taskMgr.remove(npc.uniqueName('clearMovie'))

 def requestInteract(self, avId, npc):
     toon = self.air.doId2do.get(avId)
     if not toon:
         return
     toonQuestPocketSize = toon.getQuestCarryLimit()
     self.avatarProgressTier(toon)
     toonQuests = toon.getQuests()
     for i in xrange(0, len(toonQuests), 5):
         questDesc = toonQuests[i:i + 5]
         questId, fromNpcId, toNpcId, rewardId, toonProgress = questDesc
         questClass = Quests.getQuest(questId)
         if questClass:
             completeStatus = questClass.getCompletionStatus(toon, questDesc, npc)
         else:
             continue
         if completeStatus == Quests.COMPLETE:
             print 'QuestManager: %s (AvId: %s) Completed QuestId: %s'%(toon.getName(), toon.doId, questId)
             toon.toonUp(toon.maxHp)
             if isinstance(questClass, Quests.TrackChoiceQuest):
                 npc.presentTrackChoice(avId, questId, questClass.getChoices())
                 break
             elif Quests.getNextQuest(questId, npc, toon)[0] != Quests.NA:
                 self.nextQuest(toon, npc, questId)
             else:
                 npc.completeQuest(avId, questId, rewardId)
                 self.completeQuest(toon, questId)
             if isinstance(npc, DistributedNPCSpecialQuestGiverAI):
                 if npc.tutorial and (npc.npcId == 20002):
                     messenger.send('intHqDoor0-{0}'.format(npc.zoneId), [FADoorCodes.WRONG_DOOR_HQ])
                     messenger.send('intHqDoor1-{0}'.format(npc.zoneId), [FADoorCodes.UNLOCKED])
                     streetZone = self.air.tutorialManager.currentAllocatedZones[avId][0]
                     messenger.send('extHqDoor0-{0}'.format(streetZone), [FADoorCodes.GO_TO_PLAYGROUND])
                     messenger.send('extHqDoor1-{0}'.format(streetZone), [FADoorCodes.GO_TO_PLAYGROUND])
                     messenger.send('extShopDoor-{0}'.format(streetZone), [FADoorCodes.GO_TO_PLAYGROUND])
             break
     else:
         if (len(toonQuests) == toonQuestPocketSize*5):
             npc.rejectAvatar(avId)
             return
         elif isinstance(npc, DistributedNPCSpecialQuestGiverAI):
             choices = self.avatarQuestChoice(toon, npc)
             quest = choices[0]
             self.avatarChoseQuest(avId, npc, quest[0], quest[1], 0)
             if npc.tutorial:
                 if npc.npcId == 20000:
                     messenger.send('intShopDoor-{0}'.format(npc.zoneId), [FADoorCodes.UNLOCKED])
             return
         else:
             choices = self.avatarQuestChoice(toon, npc)
             if choices != []:
                 npc.presentQuestChoice(avId, choices)
                 return
             else:
                 npc.rejectAvatar(avId)
                 return

 def giveReward(self, toon, questId, rewardId):
     #Actual reward giving.
     rewardClass = Quests.getReward(rewardId)
     rewardClass.sendRewardAI(toon)
     #Add it to reward history.
     realRewardId = Quests.transformReward(rewardId, toon)
     tier, rewardList = toon.getRewardHistory()
     rewardList.append(rewardId)
     if realRewardId != rewardId:
         rewardList.append(realRewardId)
     toon.b_setRewardHistory(tier, rewardList)

 def requestSkipTutorial(self):
     avId = self.air.getAvatarIdFromSender()
     av = self.air.doId2do.get(avId)
     if av:
         av.b_setTutorialAck(1)
         av.b_setQuestHistory([110, 100])
         av.addQuest((110, Quests.getQuestFromNpcId(110), Quests.getQuestToNpcId(110), Quests.getQuestReward(110, av), 0), 0)
         self.air.questManager.toonRodeTrolleyFirstTime(av) #gg hacky
         self.d_skipTutorialResponse(avId, 1)
     else:
         self.d_skipTutorialResponse(avId, 0)

    def recoverItems(self, av, suitsKilled, taskZoneId):
        # Get the avatars current quests.
        avQuests = av.getQuests()
        questList = []
        recoveredItems = []
        unrecoveredItems = []
        taskZoneId = ZoneUtil.getBranchZone(taskZoneId)

        # Iterate through the avatars current quests.
        for i in xrange(0, len(avQuests), 5):
            questDesc = avQuests[i : i + 5]
            questClass = Quests.getQuest(questDesc[QuestIdIndex])

            # Check if the Quest isnt already complete
            if questClass.getCompletionStatus(av, questDesc) == Quests.INCOMPLETE:

                # Check if we are dealing with a RecoverItemQuest
                if isinstance(questClass, Quests.RecoverItemQuest):

                    # Iterate through all the Cogs that were killed in the battle
                    for suit in suitsKilled:

                        # Because the RecoveItemQuest class doesn't have a
                        # function to see if a Cog counts. We need to manually
                        # check if the Cog is valid for the Quest
                        if (questClass.getHolder() == Quests.Any) or \
                            (questClass.getHolderType() == 'type' and \
                            questClass.getHolder() == suit['type']) or \
                            (questClass.getHolderType() == 'track' and \
                            questClass.getHolder() == suit['track']) or \
                            (questClass.getHolderType() == 'level' and \
                            questClass.getHolder() <= suit['level']):

                            # It looks like the Cog was valid. Lets see if they
                            # found what they were looking for.
                            baseChance = questClass.getPercentChance()
                            amountRemaining = questClass.getNumItems() - questDesc[QuestProgressIndex]
                            chance = Quests.calcRecoverChance(amountRemaining, baseChance)

                            # They found it! Give them their reward!
                            if chance >= baseChance:
                                questDesc[QuestProgressIndex] += 1
                                recoveredItems.append(questClass.getItem())

                            # Better luck next time :(
                            else:
                                unrecoveredItems.append(questClass.getItem())

            questList.append(questDesc)

        av.b_setQuests(questList)

        return (recoveredItems, unrecoveredItems)

    def __applyReward(self, av, questId, rewardId):
        Quests.getReward(rewardId).sendRewardAI(av)

        transId = Quests.transformReward(rewardId, av)
        
        tier, rewardList = av.getRewardHistory()
        
        rewardList.append(rewardId)
        if transId != rewardId:
            rewardList.append(transId)
            
        av.b_setRewardHistory(tier, rewardList)

 def requestInteract(self, avId, npc):
     av = self.air.doId2do.get(avId)
     if not av:
         self.notify.warning("Got requestInteract with unknown avId: %s" % avId)
         return
                     
     # check if the avatar wants to turn in a quest
     quests = av.getQuests()
     for i in xrange(0, len(quests), 5):
         quest = quests[i:i + 5]
         klass = Quests.getQuest(quest[0])
         
         if not klass:
             self.notify.debug('Quest %s has no class.' % quest[0])
             continue
             
         if klass.getCompletionStatus(av, quest, npc) == Quests.COMPLETE:
             # complete quest, the avatar is turning it in
             self.notify.debug("Toon %s completed quest %s" % (av.doId, quest[0]))
             
             # fill the laff
             av.toonUp(av.maxHp)
             
             if isinstance(klass, Quests.TrackChoiceQuest):
                 npc.presentTrackChoice(avId, quest[0], klass.getChoices())
                 return 1
                 
             nextQuest = Quests.getNextQuest(quest[0], npc, av)
             if nextQuest[0] != Quests.NA:
                 self.__goToNextQuest(av, npc, quest[0], nextQuest)
                 
             else:
                 npc.completeQuest(avId, quest[0], quest[-2])
                 self.__questCompleted(av, quest[0])
                 
             return 1
             
     if self.__considerProgressTier(av):
         npc.rejectAvatarTierNotDone(avId)
         return 0
             
     # give choices if the av doesn't have enough quests already
     if len(quests) / 5 < av.getQuestCarryLimit():
         choices = Quests.chooseBestQuests(av.getRewardTier(), npc, av)
         if choices:
             npc.presentQuestChoice(avId, choices)
             return 1
     
     return 0

    def giveReward(self, av, questId, rewardId):
        # Give the reward.
        rewardClass = Quests.getReward(rewardId)
        if rewardClass is None:
            self.notify.warning('rewardClass was None for rewardId: %s.' % rewardId)
        else:
            rewardClass.sendRewardAI(av)

        # Add the rewardId to the avatars rewardHistory.
        rewardTier, rewardHistory = av.getRewardHistory()
        transformedRewardId = Quests.transformReward(rewardId, av)
        if transformedRewardId != rewardId:
            rewardHistory.append(rewardId)

        av.b_setRewardHistory(rewardTier, rewardHistory)

    def __tasksChanged(self):
        self.clearMenu()
        try:
            lt = base.localAvatar
        except:
            return

        phrases = []

        def addTerminal(terminal, self=self, phrases=phrases):
            displayText = terminal.getDisplayText()
            if displayText not in phrases:
                self.append(terminal)
                phrases.append(displayText)

        for task in lt.quests:
            taskId, fromNpcId, toNpcId, rewardId, toonProgress = task
            q = Quests.getQuest(taskId)
            if q is None:
                continue
            msgs = q.getSCStrings(toNpcId, toonProgress)
            if type(msgs) != type([]):
                msgs = [msgs]
            for i in xrange(len(msgs)):
                addTerminal(TTSCToontaskTerminal(msgs[i], taskId, toNpcId, toonProgress, i))

        needToontask = 1
        if hasattr(lt, "questCarryLimit"):
            needToontask = len(lt.quests) != lt.questCarryLimit
        if needToontask:
            addTerminal(SCStaticTextTerminal(1299))
        return

 def toonKilledCogs(self, av, suits, zoneId, activeToons):
     if self.air.topToonsMgr:
         self.air.topToonsMgr.toonKilledCogs(av, suits)
         
     quests = av.getQuests()
     newQuests = []
     
     for i in xrange(0, len(quests), 5):
         quest = quests[i:i + 5]
         klass = Quests.getQuest(quest[0])
         
         if not klass:
             continue
                         
         if isinstance(klass, Quests.CogQuest):
             for suit in suits:
                 if klass.getCompletionStatus(av, quest) == Quests.COMPLETE:
                     break
                     
                 if klass.doesCogCount(av.doId, suit, zoneId, suit['activeToons']):
                     quest[4] += 1
         
         newQuests.append(quest)
         
     av.b_setQuests(newQuests)

    def toonKilledCogs(self, av, suitsKilled, zoneId):
        # Get the avatar's current quests.
        messenger.send("topToonsManager-event", [av.doId, TopToonsGlobals.CAT_COGS, len(suitsKilled)])
        avQuests = av.getQuests()
        questList = []

        # Iterate through the avatar's current quests.
        for i in xrange(0, len(avQuests), 5):
            questDesc = avQuests[i : i + 5]
            questClass = Quests.getQuest(questDesc[QuestIdIndex])

            # Check if they are doing a cog quest
            if isinstance(questClass, Quests.CogQuest):
                # Check if the cog counts...
                for suit in suitsKilled:
                    if questClass.doesCogCount(av.doId, suit, zoneId):
                        # Looks like the cog counts!
                        if questClass.getCompletionStatus(av, questDesc) != Quests.COMPLETE:
                            questDesc[QuestProgressIndex] += 1

            # Add the quest to the questList
            questList.append(questDesc)

        # Update the avatar's quests
        av.b_setQuests(questList)