def updateChange(self, value, newValue):
     self.value = value
     (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(self.category, value + newValue)
     self.max = ReputationGlobals.getReputationNeededToLevel(self.category, level)
     self.levelLabel['text'] = '%s' % level
     oldValue = leftoverValue - newValue
     if oldValue < 0:
         oldValue = 0
     
     if self.category == InventoryType.OverallRep:
         levelCap = ReputationGlobals.GlobalLevelCap
     else:
         levelCap = ReputationGlobals.LevelCap
     if level == levelCap:
         self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG4
         self.valueLabel['text_fg'] = PiratesGuiGlobals.TextFG1
         self.valueLabel['text_scale'] = 0.042999999999999997
         self.valueLabel['text'] = PLocalizer.RepCapText_Overall % level
         self.categoryLabel.hide()
         self.meter.meterFaceHalf1.hide()
         self.meter.meterFaceHalf2.hide()
         self.meter.meterFace.setColor(0.10000000000000001, 0.40000000000000002, 0.10000000000000001, 1.0)
         self.valueLabel.setZ(0.029999999999999999)
         self.showMasterOrnament()
         self.masteredFX()
     else:
         self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG1
         self.categoryLabel.show()
         self.valueLabel.hide()
         self.changeMeter.update(oldValue, leftoverValue, self.max)
         self.changeMeter.show()
         self.meter.hide()
         self.hideMasterOrnament()
 def update(self, value, playFX=False):
     self.value = value
     level, leftoverValue = ReputationGlobals.getLevelFromTotalReputation(self.category, value)
     self.max = ReputationGlobals.getReputationNeededToLevel(self.category, level)
     self.levelLabel['text'] = PLocalizer.Level + ' %s' % level
     if self.category == InventoryType.OverallRep:
         levelcap = ReputationGlobals.GlobalLevelCap
     else:
         if self.category in [InventoryType.FishingRep, InventoryType.PotionsRep]:
             levelcap = ReputationGlobals.MinigameLevelCap
         else:
             levelcap = ReputationGlobals.LevelCap
         if level >= levelcap:
             self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG1
             self.meter['range'] = self.max
             self.meter['value'] = self.max
             self.meter['barColor'] = (180 / 255.0, 190 / 255.0, 140 / 255.0, 1)
             self.valueLabel.hide()
             self.showMasterOrnament()
             if playFX:
                 self.masteredFX()
         self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG2
         self.valueLabel.show()
         self.valueLabel['text'] = '%s / %s' % (leftoverValue, self.max)
         self.meter.show()
         self.meter['range'] = self.max
         self.meter['value'] = leftoverValue
         self.meter['barColor'] = (223 / 255.0, 137 / 255.0, 28 / 255.0, 1)
         self.hideMasterOrnament()
    def update(self, value, playFX=False):
        self.value = value
        (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(self.category, value)
        self.max = ReputationGlobals.getReputationNeededToLevel(self.category, level)
        self.levelLabel["text"] = PLocalizer.Level + " %s" % level
        if self.category == InventoryType.OverallRep:
            levelcap = ReputationGlobals.GlobalLevelCap
        elif self.category in [InventoryType.FishingRep, InventoryType.PotionsRep]:
            levelcap = ReputationGlobals.MinigameLevelCap
        else:
            levelcap = ReputationGlobals.LevelCap
        if level >= levelcap:
            self.levelLabel["text_fg"] = PiratesGuiGlobals.TextFG1
            self.meter["range"] = self.max
            self.meter["value"] = self.max
            self.meter["barColor"] = (180 / 255.0, 190 / 255.0, 140 / 255.0, 1)
            self.valueLabel.hide()
            self.showMasterOrnament()
            if playFX:
                self.masteredFX()

        else:
            self.levelLabel["text_fg"] = PiratesGuiGlobals.TextFG2
            self.valueLabel.show()
            self.valueLabel["text"] = "%s / %s" % (leftoverValue, self.max)
            self.meter.show()
            self.meter["range"] = self.max
            self.meter["value"] = leftoverValue
            self.meter["barColor"] = (223 / 255.0, 137 / 255.0, 28 / 255.0, 1)
            self.hideMasterOrnament()
 def updateRep(self, category, value):
     for i in range(len(self.items)):
         repId = WeaponGlobals.getRepId(self.items[i][0])
         if repId == category:
             (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(category, value)
             max = ReputationGlobals.getReputationNeededToLevel(category, level)
             if len(self.repMeters) - 1 >= i:
                 self.repMeters[i]['range'] = max
                 self.repMeters[i]['value'] = leftoverValue
             
         len(self.repMeters) - 1 >= i
 def updateRep(self, category, value):
     for i in range(len(self.items)):
         repId = WeaponGlobals.getRepId(self.items[i][0])
         if repId == category:
             level, leftoverValue = ReputationGlobals.getLevelFromTotalReputation(
                 category, value)
             max = ReputationGlobals.getReputationNeededToLevel(
                 category, level)
             if len(self.repMeters) - 1 >= i:
                 self.repMeters[i]['range'] = max
                 self.repMeters[i]['value'] = leftoverValue
 def loadWeaponButtons(self):
     for hotkey in self.hotkeys:
         hotkey.destroy()
     
     self.hotkeys = []
     for icon in self.icons:
         icon.destroy()
     
     self.icons = []
     for repMeter in self.repMeters:
         repMeter.destroy()
     
     self.repMeters = []
     self['frameSize'] = (0, self.ICON_WIDTH * len(self.items) + 0.040000000000000001, 0, self.HEIGHT)
     self.setX(-((self.ICON_WIDTH * len(self.items) + 0.040000000000000001) / 2.0))
     topGui = loader.loadModel('models/gui/toplevel_gui')
     kbButton = topGui.find('**/keyboard_button')
     for i in range(len(self.items)):
         if self.items[i]:
             category = WeaponGlobals.getRepId(self.items[i][0])
             icon = DirectFrame(parent = self, state = DGG.DISABLED, relief = None, frameSize = (0, 0.080000000000000002, 0, 0.080000000000000002), pos = (self.ICON_WIDTH * i + 0.080000000000000002, 0, 0.082000000000000003))
             icon.setTransparency(1)
             hotkeyText = 'F%s' % self.items[i][1]
             hotkey = DirectFrame(parent = icon, state = DGG.DISABLED, relief = None, text = hotkeyText, text_align = TextNode.ACenter, text_scale = 0.044999999999999998, text_pos = (0, 0), text_fg = PiratesGuiGlobals.TextFG2, text_shadow = PiratesGuiGlobals.TextShadow, image = kbButton, image_scale = 0.059999999999999998, image_pos = (0, 0, 0.01), image_color = (0.5, 0.5, 0.34999999999999998, 1), pos = (0, 0, 0.080000000000000002))
             self.hotkeys.append(hotkey)
             category = WeaponGlobals.getRepId(self.items[i][0])
             if Freebooter.getPaidStatus(base.localAvatar.getDoId()) or Freebooter.allowedFreebooterWeapon(category):
                 asset = ItemGlobals.getIcon(self.items[i][0])
                 if asset:
                     texCard = self.card.find('**/%s' % asset)
                     icon['geom'] = texCard
                     icon['geom_scale'] = 0.080000000000000002
                 
                 icon.resetFrameSize()
                 self.icons.append(icon)
             else:
                 texCard = topGui.find('**/pir_t_gui_gen_key_subscriber*')
                 icon['geom'] = texCard
                 icon['geom_scale'] = 0.20000000000000001
                 icon.resetFrameSize()
                 self.icons.append(icon)
             repMeter = DirectWaitBar(parent = icon, relief = DGG.SUNKEN, state = DGG.DISABLED, borderWidth = (0.002, 0.002), range = 0, value = 0, frameColor = (0.23999999999999999, 0.23999999999999999, 0.20999999999999999, 1), barColor = (0.80000000000000004, 0.80000000000000004, 0.69999999999999996, 1), pos = (-0.050000000000000003, 0, -0.052499999999999998), hpr = (0, 0, 0), frameSize = (0.0050000000000000001, 0.095000000000000001, 0, 0.012500000000000001))
             self.repMeters.append(repMeter)
             inv = base.localAvatar.getInventory()
             if inv:
                 repValue = inv.getReputation(category)
                 (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(category, repValue)
                 max = ReputationGlobals.getReputationNeededToLevel(category, level)
                 repMeter['range'] = max
                 repMeter['value'] = leftoverValue
    def update(self, value, updateLocal=0):
        if self.mastered:
            return None

        self.value = value
        (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(
            self.category, value)
        self.max = ReputationGlobals.getReputationNeededToLevel(
            self.category, level)
        self.levelLabel['text'] = '%s' % level
        if self.category == InventoryType.OverallRep:
            levelCap = ReputationGlobals.GlobalLevelCap
            if updateLocal and level != self.level:
                localAvatar.setLevel(level)

        else:
            levelCap = ReputationGlobals.LevelCap
        self.level = level
        if level == levelCap:
            self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG4
            self.valueLabel['text_fg'] = PiratesGuiGlobals.TextFG1
            self.valueLabel['text_scale'] = 0.042999999999999997
            self.valueLabel['text'] = PLocalizer.RepCapText_Overall % level
            self.categoryLabel.hide()
            self.meter.meterFaceHalf1.hide()
            self.meter.meterFaceHalf2.hide()
            self.meter.meterFace.setColor(0.10000000000000001,
                                          0.40000000000000002,
                                          0.10000000000000001, 1.0)
            self.valueLabel.setZ(0.029999999999999999)
            self.showMasterOrnament()
            self.masteredFX()
        else:
            self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG1
            self.meter.show()
            self.categoryLabel.show()
            self.valueLabel['text'] = '%s / %s' % (leftoverValue, self.max)
            self.valueLabel['text_scale'] = PiratesGuiGlobals.TextScaleLarge
            self.valueLabel['text_fg'] = PiratesGuiGlobals.TextFG2
            self.valueLabel.setZ(0.0)
            self.meter.update(leftoverValue, self.max)
            self.hideMasterOrnament()
            if self.lastLevel == None:
                self.lastLevel = level

            if self.lastExp == None:
                if hasattr(base, 'localAvatar'):
                    self.lastExp = localAvatar.getInventory().getReputation(
                        self.category)

            if self.lastExp:
                expChange = value - self.lastExp
                if expChange and localAvatar.getGameState() != 'Fishing':
                    localAvatar.guiMgr.gameGui.createExpAlert(
                        expChange, 4.0, Vec3(-0.93000000000000005, 0.0, 0.75),
                        Vec3(0.0, 0.0, 0.25))

            if self.lastLevel != level:
                self.lastLevel = level
                glowFrameColor = Vec4(0.69999999999999996, 0.0, 0.0, 1.0)
                glowLevelColor = Vec4(0.80000000000000004, 0.0, 0.0, 1.0)
                startFrameColor = self.meter.meterFace.getColor()
                startLevelColor = Vec4(0.90000000000000002,
                                       0.80000000000000004, 0.63, 1.0)
                startFrameScale = self.meter.meterFace.getScale()
                startLevelScale = self.levelLabel.getScale()
                scale = Vec3(1.2, 1.2, 1.2)
                objFrame = self.meter.meterFace
                objLevel = self.levelLabel
                levelUpIval = Sequence(
                    Func(self.meter.meterFaceHalf1.hide),
                    Func(self.meter.meterFaceHalf2.hide),
                    Parallel(
                        LerpColorInterval(objFrame,
                                          3.0,
                                          startFrameColor,
                                          glowFrameColor,
                                          blendType='easeInOut'),
                        LerpColorInterval(objLevel,
                                          3.0,
                                          startLevelColor,
                                          glowLevelColor,
                                          blendType='easeInOut'),
                        Sequence(
                            LerpScaleInterval(objLevel,
                                              0.25,
                                              scale,
                                              startFrameScale,
                                              blendType='easeInOut'),
                            LerpScaleInterval(objLevel,
                                              2.0,
                                              startFrameScale,
                                              blendType='easeInOut'))),
                    Func(self.meter.meterFaceHalf1.show),
                    Func(self.meter.meterFaceHalf2.show),
                    Func(objLevel.clearColor))
                levelUpIval.start()
            elif self.lastExp is not None:
                if self.lastExp == value:
                    return None

            self.lastExp = value
            glowFrameColor = Vec4(1.0, 0, 0, 1.0)
            startFrameColorA = self.meter.meterFaceHalf1.getColor()
            startFrameColorB = self.meter.meterFaceHalf2.getColor()
            objFrameA = self.meter.meterFaceHalf1
            objFrameB = self.meter.meterFaceHalf2
            objFrameC = self.meter.meterFace
            if leftoverValue and float(self.max) / float(leftoverValue) > 2.0:
                expUpIval = Sequence(
                    LerpColorScaleInterval(objFrameA,
                                           0.20000000000000001,
                                           glowFrameColor,
                                           blendType='easeInOut'),
                    Wait(0.20000000000000001),
                    LerpColorScaleInterval(objFrameA,
                                           0.5,
                                           startFrameColorA,
                                           blendType='easeInOut'),
                    LerpColorScaleInterval(objFrameA,
                                           0.10000000000000001,
                                           glowFrameColor,
                                           blendType='easeInOut'),
                    Wait(0.10000000000000001),
                    LerpColorScaleInterval(objFrameA,
                                           0.29999999999999999,
                                           startFrameColorA,
                                           blendType='easeInOut'))
            else:
                expUpIval = Sequence(
                    Parallel(
                        LerpColorScaleInterval(objFrameA,
                                               0.20000000000000001,
                                               glowFrameColor,
                                               blendType='easeInOut'),
                        LerpColorScaleInterval(objFrameB,
                                               0.20000000000000001,
                                               glowFrameColor,
                                               blendType='easeInOut')),
                    Wait(0.20000000000000001),
                    Parallel(
                        LerpColorScaleInterval(objFrameA,
                                               0.5,
                                               startFrameColorA,
                                               blendType='easeInOut'),
                        LerpColorScaleInterval(objFrameB,
                                               0.5,
                                               startFrameColorA,
                                               blendType='easeInOut')),
                    Parallel(
                        LerpColorScaleInterval(objFrameA,
                                               0.10000000000000001,
                                               glowFrameColor,
                                               blendType='easeInOut'),
                        LerpColorScaleInterval(objFrameB,
                                               0.10000000000000001,
                                               glowFrameColor,
                                               blendType='easeInOut')),
                    Wait(0.10000000000000001),
                    Parallel(
                        LerpColorScaleInterval(objFrameA,
                                               0.29999999999999999,
                                               startFrameColorA,
                                               blendType='easeInOut'),
                        LerpColorScaleInterval(objFrameB,
                                               0.29999999999999999,
                                               startFrameColorA,
                                               blendType='easeInOut')))
            expUpIval.start()
 def update(self, value, updateLocal = 0):
     if self.mastered:
         return None
     
     self.value = value
     (level, leftoverValue) = ReputationGlobals.getLevelFromTotalReputation(self.category, value)
     self.max = ReputationGlobals.getReputationNeededToLevel(self.category, level)
     self.levelLabel['text'] = '%s' % level
     if self.category == InventoryType.OverallRep:
         levelCap = ReputationGlobals.GlobalLevelCap
         if updateLocal and level != self.level:
             localAvatar.setLevel(level)
         
     else:
         levelCap = ReputationGlobals.LevelCap
     self.level = level
     if level == levelCap:
         self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG4
         self.valueLabel['text_fg'] = PiratesGuiGlobals.TextFG1
         self.valueLabel['text_scale'] = 0.042999999999999997
         self.valueLabel['text'] = PLocalizer.RepCapText_Overall % level
         self.categoryLabel.hide()
         self.meter.meterFaceHalf1.hide()
         self.meter.meterFaceHalf2.hide()
         self.meter.meterFace.setColor(0.10000000000000001, 0.40000000000000002, 0.10000000000000001, 1.0)
         self.valueLabel.setZ(0.029999999999999999)
         self.showMasterOrnament()
         self.masteredFX()
     else:
         self.levelLabel['text_fg'] = PiratesGuiGlobals.TextFG1
         self.meter.show()
         self.categoryLabel.show()
         self.valueLabel['text'] = '%s / %s' % (leftoverValue, self.max)
         self.valueLabel['text_scale'] = PiratesGuiGlobals.TextScaleLarge
         self.valueLabel['text_fg'] = PiratesGuiGlobals.TextFG2
         self.valueLabel.setZ(0.0)
         self.meter.update(leftoverValue, self.max)
         self.hideMasterOrnament()
         if self.lastLevel == None:
             self.lastLevel = level
         
         if self.lastExp == None:
             if hasattr(base, 'localAvatar'):
                 self.lastExp = localAvatar.getInventory().getReputation(self.category)
             
         
         if self.lastExp:
             expChange = value - self.lastExp
             if expChange and localAvatar.getGameState() != 'Fishing':
                 localAvatar.guiMgr.gameGui.createExpAlert(expChange, 4.0, Vec3(-0.93000000000000005, 0.0, 0.75), Vec3(0.0, 0.0, 0.25))
             
         
         if self.lastLevel != level:
             self.lastLevel = level
             glowFrameColor = Vec4(0.69999999999999996, 0.0, 0.0, 1.0)
             glowLevelColor = Vec4(0.80000000000000004, 0.0, 0.0, 1.0)
             startFrameColor = self.meter.meterFace.getColor()
             startLevelColor = Vec4(0.90000000000000002, 0.80000000000000004, 0.63, 1.0)
             startFrameScale = self.meter.meterFace.getScale()
             startLevelScale = self.levelLabel.getScale()
             scale = Vec3(1.2, 1.2, 1.2)
             objFrame = self.meter.meterFace
             objLevel = self.levelLabel
             levelUpIval = Sequence(Func(self.meter.meterFaceHalf1.hide), Func(self.meter.meterFaceHalf2.hide), Parallel(LerpColorInterval(objFrame, 3.0, startFrameColor, glowFrameColor, blendType = 'easeInOut'), LerpColorInterval(objLevel, 3.0, startLevelColor, glowLevelColor, blendType = 'easeInOut'), Sequence(LerpScaleInterval(objLevel, 0.25, scale, startFrameScale, blendType = 'easeInOut'), LerpScaleInterval(objLevel, 2.0, startFrameScale, blendType = 'easeInOut'))), Func(self.meter.meterFaceHalf1.show), Func(self.meter.meterFaceHalf2.show), Func(objLevel.clearColor))
             levelUpIval.start()
         elif self.lastExp is not None:
             if self.lastExp == value:
                 return None
             
         
         self.lastExp = value
         glowFrameColor = Vec4(1.0, 0, 0, 1.0)
         startFrameColorA = self.meter.meterFaceHalf1.getColor()
         startFrameColorB = self.meter.meterFaceHalf2.getColor()
         objFrameA = self.meter.meterFaceHalf1
         objFrameB = self.meter.meterFaceHalf2
         objFrameC = self.meter.meterFace
         if leftoverValue and float(self.max) / float(leftoverValue) > 2.0:
             expUpIval = Sequence(LerpColorScaleInterval(objFrameA, 0.20000000000000001, glowFrameColor, blendType = 'easeInOut'), Wait(0.20000000000000001), LerpColorScaleInterval(objFrameA, 0.5, startFrameColorA, blendType = 'easeInOut'), LerpColorScaleInterval(objFrameA, 0.10000000000000001, glowFrameColor, blendType = 'easeInOut'), Wait(0.10000000000000001), LerpColorScaleInterval(objFrameA, 0.29999999999999999, startFrameColorA, blendType = 'easeInOut'))
         else:
             expUpIval = Sequence(Parallel(LerpColorScaleInterval(objFrameA, 0.20000000000000001, glowFrameColor, blendType = 'easeInOut'), LerpColorScaleInterval(objFrameB, 0.20000000000000001, glowFrameColor, blendType = 'easeInOut')), Wait(0.20000000000000001), Parallel(LerpColorScaleInterval(objFrameA, 0.5, startFrameColorA, blendType = 'easeInOut'), LerpColorScaleInterval(objFrameB, 0.5, startFrameColorA, blendType = 'easeInOut')), Parallel(LerpColorScaleInterval(objFrameA, 0.10000000000000001, glowFrameColor, blendType = 'easeInOut'), LerpColorScaleInterval(objFrameB, 0.10000000000000001, glowFrameColor, blendType = 'easeInOut')), Wait(0.10000000000000001), Parallel(LerpColorScaleInterval(objFrameA, 0.29999999999999999, startFrameColorA, blendType = 'easeInOut'), LerpColorScaleInterval(objFrameB, 0.29999999999999999, startFrameColorA, blendType = 'easeInOut')))
         expUpIval.start()
Exemple #9
0
    def loadWeaponButtons(self):
        for hotkey in self.hotkeys:
            hotkey.destroy()

        self.hotkeys = []
        for icon in self.icons:
            icon.destroy()

        self.icons = []
        for repMeter in self.repMeters:
            repMeter.destroy()

        self.repMeters = []
        self['frameSize'] = (0, self.ICON_WIDTH * len(self.items) +
                             0.040000000000000001, 0, self.HEIGHT)
        self.setX(-(
            (self.ICON_WIDTH * len(self.items) + 0.040000000000000001) / 2.0))
        topGui = loader.loadModel('models/gui/toplevel_gui')
        kbButton = topGui.find('**/keyboard_button')
        for i in range(len(self.items)):
            if self.items[i]:
                category = WeaponGlobals.getRepId(self.items[i][0])
                icon = DirectFrame(
                    parent=self,
                    state=DGG.DISABLED,
                    relief=None,
                    frameSize=(0, 0.080000000000000002, 0,
                               0.080000000000000002),
                    pos=(self.ICON_WIDTH * i + 0.080000000000000002, 0,
                         0.082000000000000003))
                icon.setTransparency(1)
                hotkeyText = 'F%s' % self.items[i][1]
                hotkey = DirectFrame(parent=icon,
                                     state=DGG.DISABLED,
                                     relief=None,
                                     text=hotkeyText,
                                     text_align=TextNode.ACenter,
                                     text_scale=0.044999999999999998,
                                     text_pos=(0, 0),
                                     text_fg=PiratesGuiGlobals.TextFG2,
                                     text_shadow=PiratesGuiGlobals.TextShadow,
                                     image=kbButton,
                                     image_scale=0.059999999999999998,
                                     image_pos=(0, 0, 0.01),
                                     image_color=(0.5, 0.5,
                                                  0.34999999999999998, 1),
                                     pos=(0, 0, 0.080000000000000002))
                self.hotkeys.append(hotkey)
                category = WeaponGlobals.getRepId(self.items[i][0])
                if Freebooter.getPaidStatus(base.localAvatar.getDoId(
                )) or Freebooter.allowedFreebooterWeapon(category):
                    asset = ItemGlobals.getIcon(self.items[i][0])
                    if asset:
                        texCard = self.card.find('**/%s' % asset)
                        icon['geom'] = texCard
                        icon['geom_scale'] = 0.080000000000000002

                    icon.resetFrameSize()
                    self.icons.append(icon)
                else:
                    texCard = topGui.find('**/pir_t_gui_gen_key_subscriber*')
                    icon['geom'] = texCard
                    icon['geom_scale'] = 0.20000000000000001
                    icon.resetFrameSize()
                    self.icons.append(icon)
                repMeter = DirectWaitBar(
                    parent=icon,
                    relief=DGG.SUNKEN,
                    state=DGG.DISABLED,
                    borderWidth=(0.002, 0.002),
                    range=0,
                    value=0,
                    frameColor=(0.23999999999999999, 0.23999999999999999,
                                0.20999999999999999, 1),
                    barColor=(0.80000000000000004, 0.80000000000000004,
                              0.69999999999999996, 1),
                    pos=(-0.050000000000000003, 0, -0.052499999999999998),
                    hpr=(0, 0, 0),
                    frameSize=(0.0050000000000000001, 0.095000000000000001, 0,
                               0.012500000000000001))
                self.repMeters.append(repMeter)
                inv = base.localAvatar.getInventory()
                if inv:
                    repValue = inv.getReputation(category)
                    (level, leftoverValue
                     ) = ReputationGlobals.getLevelFromTotalReputation(
                         category, repValue)
                    max = ReputationGlobals.getReputationNeededToLevel(
                        category, level)
                    repMeter['range'] = max
                    repMeter['value'] = leftoverValue