def getTeamStats(self, team):
        teams = {}
        displayStats = []
        for playerId, stats in self.stats.items():
            if playerId not in self.names:
                continue
            playerName = self.names[playerId]
            playerTeam = self.teams[playerId]
            if team and playerTeam != team:
                continue
            if not teams.get(playerTeam):
                teams[playerTeam] = []
            playerStats = []
            for stat in self.getColumnStats():
                playerStats.append([PVPGlobals.statText[stat], str(stats[stat])])

            if playerId == localAvatar.doId:
                playerColor = (1, 1, 1, 1)
            else:
                playerColor = PVPGlobals.getTeamColor(playerTeam)
            teams[playerTeam].append([playerName, playerStats, ['color', playerColor]])

        if team:
            if not teams.has_key(team):
                return displayStats
            teamStats = teams[team]
            teamTotals = []
            for stat in self.getColumnStats():
                teamTotals.append([PVPGlobals.statText[stat], 0])

            for playerName, playerStats, color in teamStats:
                for i in range(len(playerStats)):
                    teamTotals[i][1] = str(int(teamTotals[i][1]) + int(playerStats[i][1]))

            teamStat = [
             PLocalizer.PVPTeamTotal, teamTotals, ['color', PVPGlobals.getTeamColor(team)]]
            teamStats = self.sortStats(teamStats)
            teamStats.append(teamStat)
            displayStats = teamStats
        else:
            for team, teamStats in teams.items():
                teamTotals = []
                for stat in self.getColumnStats():
                    teamTotals.append([PVPGlobals.statText[stat], 0])

                for playerName, playerStats, color in teamStats:
                    for i in range(len(playerStats)):
                        teamTotals[i][1] = str(int(teamTotals[i][1]) + int(playerStats[i][1]))

                teamStats = self.sortStats(teamStats)
                displayStats += teamStats

        displayStats.insert(0, self.getColumnLabels())
        return displayStats
Ejemplo n.º 2
0
 def getPlayerStats(self):
     displayStats = []
     for (playerId, stats) in self.stats.items():
         if playerId not in self.names:
             continue
         
         playerName = self.names[playerId]
         playerTeam = self.teams[playerId]
         playerStats = []
         for stat in self.getColumnStats():
             playerStats.append([
                 PVPGlobals.statText[stat],
                 str(stats[stat])])
         
         if playerId == localAvatar.doId:
             playerColor = (1, 1, 1, 1)
         else:
             playerColor = PVPGlobals.getTeamColor(playerTeam)
         displayStats.append([
             playerName,
             playerStats,
             [
                 'color',
                 playerColor]])
     
     displayStats = self.sortStats(displayStats)
     displayStats.insert(0, self.getColumnLabels())
     return displayStats
 def showBeacon(self, team):
     if self.beacon:
         self.hideBeacon()
     if team > 0:
         self.beaconNodePath = self.nametag3d.attachNewNode('beacon')
         self.beacon = Beacon.getBeacon(self.beaconNodePath)
         self.beacon.setZ(2)
         self.beacon.setBillboardPointWorld()
         self.exposeJoint(self.beaconNodePath, 'modelRoot', 'name_tag', '500')
         self.beacon.setColor(PVPGlobals.getTeamColor(team))
    def setTeamGraphic(self, team):
        if self.pvpTeamGraphic:
            self.pvpTeamGraphic.removeNode()
            self.pvpTeamGraphic = None

        if team > 0:
            self.pvpTeamGraphic = Beacon.getBeaconModel()
            self.pvpTeamGraphic.reparentTo(self)
            self.pvpTeamGraphic.setColor(PVPGlobals.getTeamColor(team))
            self.pvpTeamGraphic.setScale(0.23000000000000001)
            self.pvpTeamGraphic.setPos(0.13, 0, 0.13)
 def setTeamGraphic(self, team):
     if self.pvpTeamGraphic:
         self.pvpTeamGraphic.removeNode()
         self.pvpTeamGraphic = None
     
     if team > 0:
         self.pvpTeamGraphic = Beacon.getBeaconModel()
         self.pvpTeamGraphic.reparentTo(self)
         self.pvpTeamGraphic.setColor(PVPGlobals.getTeamColor(team))
         self.pvpTeamGraphic.setScale(0.23000000000000001)
         self.pvpTeamGraphic.setPos(0.13, 0, 0.13)
 def showBeacon(self, team):
     if self.beacon:
         self.hideBeacon()
     
     if team > 0:
         self.beaconNodePath = self.nametag3d.attachNewNode('beacon')
         self.beacon = Beacon.getBeacon(self.beaconNodePath)
         self.beacon.setZ(2)
         self.beacon.setBillboardPointWorld()
         self.exposeJoint(self.beaconNodePath, 'modelRoot', 'name_tag', '500')
         self.beacon.setColor(PVPGlobals.getTeamColor(team))
Ejemplo n.º 7
0
 def __init__(self, name, pvp):
     self.width = PiratesGuiGlobals.PVPCompletePanelWidth
     self.height = PiratesGuiGlobals.PVPCompletePanelHeight
     BorderFrame.__init__(self, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, self.height * 0.81999999999999995, self.height), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.94999999999999996, 0.75))
     self.secondLayer = BorderFrame(parent = self, relief = None, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, self.height * 0.81999999999999995, self.height), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.initialiseoptions(PVPCompletePanel)
     self.endButton = GuiButton(parent = self, text = PLocalizer.PVPExit, command = pvp.requestPVPLeave, pos = (1.25, 0, 0.10000000000000001), image = GuiButton.redGenericButton, image_scale = 0.59999999999999998)
     self.endButton.setBin('gui-popup', 0)
     self.name = name
     self.title = DirectLabel(parent = self, relief = None, text = name, text_align = TextNode.ACenter, text_scale = 0.070000000000000007, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.25, 0, 1.6200000000000001))
     if pvp.hasTeams():
         team1Score = '0'
         team2Score = '0'
         for stat in pvp.scoreboardHolder.getItemList():
             if stat['Team'] == 1:
                 team1Score = stat['Score']
                 continue
             if stat['Team'] == 2:
                 team2Score = stat['Score']
                 continue
         
         self.team1ScoreLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.PVPTeamScore % (1, team1Score), text_align = TextNode.ACenter, text_scale = 0.040000000000000001, text_fg = PVPGlobals.getTeamColor(1), text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.05, 0, 1.55))
         self.team2ScoreLabel = DirectLabel(parent = self, relief = None, text = PLocalizer.PVPTeamScore % (2, team2Score), text_align = TextNode.ACenter, text_scale = 0.040000000000000001, text_fg = PVPGlobals.getTeamColor(2), text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.45, 0, 1.55))
     
     self.outcome = DirectLabel(parent = self, relief = None, text = '', text_align = TextNode.ACenter, text_scale = 0.059999999999999998, text_fg = PiratesGuiGlobals.TextFG1, text_shadow = PiratesGuiGlobals.TextShadow, textMayChange = 1, pos = (1.25, 0, 1.45))
     if pvp.hasTeams():
         if team1Score > team2Score:
             self.outcome['text_fg'] = PVPGlobals.getTeamColor(1)
         elif team2Score > team1Score:
             self.outcome['text_fg'] = PVPGlobals.getTeamColor(2)
         
     
     self.borderTwo = BorderFrame(parent = self, relief = None, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, 0, self.height * 0.80000000000000004), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.borderTwoSecondLayer = BorderFrame(parent = self.borderTwo, relief = None, frameSize = (self.width * 0.14999999999999999, self.width * 0.84999999999999998, 0, self.height * 0.80000000000000004), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.two = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.0, PiratesGuiGlobals.PVPCompletePageHeight, pvp.statsHolder, 0, sortOrder = 2)
     self.two.reparentTo(self.borderTwo)
     self.two.setPos(0.45000000000000001, 0, -0.14999999999999999)
     self.two.setup()
     self.game = pvp
Ejemplo n.º 8
0
 def createScoreboardItem(self, item, parent, itemType=None, columnWidths=[], color=None):
     itemColorScale = None
     player = item.get('Player')
     score = item.get('Score')
     playerName = self.names[player]
     playerTeam = self.teams[player]
     if player == localAvatar.doId:
         itemColorScale = (1, 1, 1, 1)
     else:
         if playerTeam != None:
             itemColorScale = PVPGlobals.getTeamColor(playerTeam)
     item['Player'] = playerName
     return MiniScoreItemGui(item, parent, self, itemColorScale)
Ejemplo n.º 9
0
 def createScoreboardItem(self, item, parent, itemType = None, columnWidths = [], color = None):
     itemColorScale = None
     player = item.get('Player')
     score = item.get('Score')
     playerName = self.names[player]
     playerTeam = self.teams[player]
     if player == localAvatar.doId:
         itemColorScale = (1, 1, 1, 1)
     elif playerTeam != None:
         itemColorScale = PVPGlobals.getTeamColor(playerTeam)
     
     item['Player'] = playerName
     return MiniScoreItemGui(item, parent, self, itemColorScale)
 def createScoreboardItem(self, item, parent, itemType = None, columnWidths = [], color = None):
     itemColorScale = None
     blink = False
     team = item.get('Team')
     score = item.get('Score')
     if team == localAvatar.getTeam():
         if self.prevTeamScore != None and score < self.prevTeamScore:
             blink = True
         
         self.prevTeamScore = score
     
     if team != localAvatar.doId:
         itemColorScale = PVPGlobals.getTeamColor(team)
     else:
         itemColorScale = (1, 1, 1, 1)
     return MiniScoreItemGui(item, parent, self, itemColorScale, blink)
Ejemplo n.º 11
0
 def createScoreboardItem(self, item, parent, itemType = None, columnWidths = [], color = None):
     itemColorScale = None
     blink = False
     team = item.get('Team')
     score = item.get('Score')
     if team == localAvatar.getTeam():
         if self.prevTeamScore != None and score < self.prevTeamScore:
             blink = True
         
         self.prevTeamScore = score
     
     if team != localAvatar.doId:
         itemColorScale = PVPGlobals.getTeamColor(team)
     else:
         itemColorScale = (1, 1, 1, 1)
     return MiniScoreItemGui(item, parent, self, itemColorScale, blink)
    def getItemList(self, team):
        sortedScores = self.getTeamScores(team)
        displayScores = []
        for scoreItemDict in sortedScores:
            id = scoreItemDict.get("ID")
            score = scoreItemDict.get("Score")
            stats = [["Score", str(score)]]
            for (stat, dict) in self._stats.iteritems():
                stats.append([PVPGlobals.statText[stat], str(dict.get(id))])

            if localAvatar.getShip() and localAvatar.getShip().doId == id:
                displayScores.append([self._names[id], stats, ["color", (1, 1, 1, 1)]])
                continue
            displayScores.append([self._names[id], stats, ["color", PVPGlobals.getSiegeColor(self._teams[id])]])

        displayScores.insert(0, self.getColumnLabels())
        return displayScores
Ejemplo n.º 13
0
    def getItemList(self, team):
        sortedScores = self.getTeamScores(team)
        displayScores = []
        for scoreItemDict in sortedScores:
            id = scoreItemDict.get('ID')
            score = scoreItemDict.get('Score')
            stats = [['Score', str(score)]]
            for stat, dict in self._stats.iteritems():
                stats.append([PVPGlobals.statText[stat], str(dict.get(id))])

            if localAvatar.getShip() and localAvatar.getShip().doId == id:
                displayScores.append([self._names[id], stats, ['color', (1, 1, 1, 1)]])
            else:
                displayScores.append([self._names[id], stats, ['color', PVPGlobals.getSiegeColor(self._teams[id])]])

        displayScores.insert(0, self.getColumnLabels())
        return displayScores
    def getPlayerStats(self):
        displayStats = []
        for playerId, stats in self.stats.items():
            if playerId not in self.names:
                continue
            playerName = self.names[playerId]
            playerTeam = self.teams[playerId]
            playerStats = []
            for stat in self.getColumnStats():
                playerStats.append([PVPGlobals.statText[stat], str(stats[stat])])

            if playerId == localAvatar.doId:
                playerColor = (1, 1, 1, 1)
            else:
                playerColor = PVPGlobals.getTeamColor(playerTeam)
            displayStats.append([playerName, playerStats, ['color', playerColor]])

        displayStats = self.sortStats(displayStats)
        displayStats.insert(0, self.getColumnLabels())
        return displayStats
Ejemplo n.º 15
0
 def updateIcon(self, doId):
     target = base.cr.doId2do.get(doId)
     if not target:
         return
     if self.currentIcon:
         self.currentIcon.hide()
     pvpTeam = target.getPVPTeam()
     siegeTeam = target.getSiegeTeam()
     if pvpTeam:
         icon = self.pvpIcon
         self.pvpIcon.setColor(PVPGlobals.getTeamColor(pvpTeam))
     else:
         if siegeTeam:
             icon = self.privateerLogos[siegeTeam]
         else:
             icon = self.icons.get(target.getTeam(), None)
     if icon:
         icon.reparentTo(self.enemyFrame)
         icon.show()
     self.currentIcon = icon
     return
    def updateIcon(self, doId):
        target = base.cr.doId2do.get(doId)
        if not target:
            return None

        if self.currentIcon:
            self.currentIcon.hide()

        pvpTeam = target.getPVPTeam()
        siegeTeam = target.getSiegeTeam()
        if pvpTeam:
            icon = self.pvpIcon
            self.pvpIcon.setColor(PVPGlobals.getTeamColor(pvpTeam))
        elif siegeTeam:
            icon = self.privateerLogos[siegeTeam]
        else:
            icon = self.icons.get(target.getTeam(), None)
        if icon:
            icon.reparentTo(self.enemyFrame)
            icon.show()

        self.currentIcon = icon
 def __init__(self, holder):
     pvpIcons = loader.loadModel('models/textureCards/pvp_arrow')
     self.holder = holder
     hasTeams = holder.hasTeams()
     self.borderOne = BorderFrame.BorderFrame(relief = None, frameSize = (-(PiratesGuiGlobals.PVPCompletePageWidth) * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageWidth * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageHeight * 0.5 - 0.10000000000000001 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) * len(holder.getItemList(1)), PiratesGuiGlobals.PVPCompletePageHeight * 0.5), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.borderOneSecondLayer = BorderFrame.BorderFrame(parent = self.borderOne, relief = None, text = '', text_scale = 0.074999999999999997, text_fg = PVPGlobals.getTeamColor(1), text_pos = (-0.65000000000000002, 0.64000000000000001), frameSize = (-(PiratesGuiGlobals.PVPCompletePageWidth) * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageWidth * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageHeight * 0.5 - 0.10000000000000001 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) * len(holder.getItemList(1)), PiratesGuiGlobals.PVPCompletePageHeight * 0.5), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.borderOne.setPos(0.0625, 0, -0.10000000000000001)
     if hasTeams:
         self.borderOneSecondLayer['text'] = PLocalizer.PVPTeamName % 1
         self.one = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.2, PiratesGuiGlobals.PVPCompletePageHeight, holder, 1, sortOrder = 2)
         self.one.setPos(-0.5, 0, -0.84999999999999998)
     else:
         self.one = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.0, PiratesGuiGlobals.PVPCompletePageHeight, holder, 1, sortOrder = 2)
         self.one.setPos(-0.73999999999999999, 0, -0.84999999999999998)
     self.borderOne.hide()
     self.one.hide()
     if hasTeams:
         self.borderTwo = BorderFrame.BorderFrame(relief = None, frameSize = (-(PiratesGuiGlobals.PVPCompletePageWidth) * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageWidth * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageHeight * 0.5 - 0.10000000000000001 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) * len(holder.getItemList(2)), PiratesGuiGlobals.PVPCompletePageHeight * 0.5), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
         self.borderTwoSecondLayer = BorderFrame.BorderFrame(parent = self.borderTwo, relief = None, text = PLocalizer.PVPTeamName % 2, text_scale = 0.074999999999999997, text_fg = PVPGlobals.getTeamColor(2), text_pos = (-0.65000000000000002, 0.64000000000000001), frameSize = (-(PiratesGuiGlobals.PVPCompletePageWidth) * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageWidth * 0.33000000000000002, PiratesGuiGlobals.PVPCompletePageHeight * 0.5 - 0.10000000000000001 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) * len(holder.getItemList(2)), PiratesGuiGlobals.PVPCompletePageHeight * 0.5), modelName = 'pir_m_gui_frm_subframe', imageColorScale = VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
         self.two = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.2, PiratesGuiGlobals.PVPCompletePageHeight, holder, 2, sortOrder = 2)
         self.borderTwo.setPos(0.0625, 0, -0.25 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) * len(holder.getItemList(1)))
         self.two.setPos(-0.5, 0, -1.0 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) * len(holder.getItemList(1)))
         self.borderTwo.hide()
         self.two.hide()
     else:
         self.borderTwo = None
         self.two = None
Ejemplo n.º 18
0
    def __init__(self, name, pvp):
        self.width = PiratesGuiGlobals.PVPCompletePanelWidth
        self.height = PiratesGuiGlobals.PVPCompletePanelHeight
        BorderFrame.__init__(self,
                             frameSize=(self.width * 0.14999999999999999,
                                        self.width * 0.84999999999999998,
                                        self.height * 0.81999999999999995,
                                        self.height),
                             modelName='pir_m_gui_frm_subframe',
                             imageColorScale=VBase4(0.75, 0.75,
                                                    0.94999999999999996, 0.75))
        self.secondLayer = BorderFrame(
            parent=self,
            relief=None,
            frameSize=(self.width * 0.14999999999999999,
                       self.width * 0.84999999999999998,
                       self.height * 0.81999999999999995, self.height),
            modelName='pir_m_gui_frm_subframe',
            imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
        self.initialiseoptions(PVPCompletePanel)
        self.endButton = GuiButton(parent=self,
                                   text=PLocalizer.PVPExit,
                                   command=pvp.requestPVPLeave,
                                   pos=(1.25, 0, 0.10000000000000001),
                                   image=GuiButton.redGenericButton,
                                   image_scale=0.59999999999999998)
        self.endButton.setBin('gui-popup', 0)
        self.name = name
        self.title = DirectLabel(parent=self,
                                 relief=None,
                                 text=name,
                                 text_align=TextNode.ACenter,
                                 text_scale=0.070000000000000007,
                                 text_fg=PiratesGuiGlobals.TextFG1,
                                 text_shadow=PiratesGuiGlobals.TextShadow,
                                 textMayChange=1,
                                 pos=(1.25, 0, 1.6200000000000001))
        if pvp.hasTeams():
            team1Score = '0'
            team2Score = '0'
            for stat in pvp.scoreboardHolder.getItemList():
                if stat['Team'] == 1:
                    team1Score = stat['Score']
                    continue
                if stat['Team'] == 2:
                    team2Score = stat['Score']
                    continue

            self.team1ScoreLabel = DirectLabel(
                parent=self,
                relief=None,
                text=PLocalizer.PVPTeamScore % (1, team1Score),
                text_align=TextNode.ACenter,
                text_scale=0.040000000000000001,
                text_fg=PVPGlobals.getTeamColor(1),
                text_shadow=PiratesGuiGlobals.TextShadow,
                textMayChange=1,
                pos=(1.05, 0, 1.55))
            self.team2ScoreLabel = DirectLabel(
                parent=self,
                relief=None,
                text=PLocalizer.PVPTeamScore % (2, team2Score),
                text_align=TextNode.ACenter,
                text_scale=0.040000000000000001,
                text_fg=PVPGlobals.getTeamColor(2),
                text_shadow=PiratesGuiGlobals.TextShadow,
                textMayChange=1,
                pos=(1.45, 0, 1.55))

        self.outcome = DirectLabel(parent=self,
                                   relief=None,
                                   text='',
                                   text_align=TextNode.ACenter,
                                   text_scale=0.059999999999999998,
                                   text_fg=PiratesGuiGlobals.TextFG1,
                                   text_shadow=PiratesGuiGlobals.TextShadow,
                                   textMayChange=1,
                                   pos=(1.25, 0, 1.45))
        if pvp.hasTeams():
            if team1Score > team2Score:
                self.outcome['text_fg'] = PVPGlobals.getTeamColor(1)
            elif team2Score > team1Score:
                self.outcome['text_fg'] = PVPGlobals.getTeamColor(2)

        self.borderTwo = BorderFrame(
            parent=self,
            relief=None,
            frameSize=(self.width * 0.14999999999999999,
                       self.width * 0.84999999999999998, 0,
                       self.height * 0.80000000000000004),
            modelName='pir_m_gui_frm_subframe',
            imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
        self.borderTwoSecondLayer = BorderFrame(
            parent=self.borderTwo,
            relief=None,
            frameSize=(self.width * 0.14999999999999999,
                       self.width * 0.84999999999999998, 0,
                       self.height * 0.80000000000000004),
            modelName='pir_m_gui_frm_subframe',
            imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
        self.two = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.0,
                              PiratesGuiGlobals.PVPCompletePageHeight,
                              pvp.statsHolder,
                              0,
                              sortOrder=2)
        self.two.reparentTo(self.borderTwo)
        self.two.setPos(0.45000000000000001, 0, -0.14999999999999999)
        self.two.setup()
        self.game = pvp
Ejemplo n.º 19
0
 def __init__(self, holder):
     pvpIcons = loader.loadModel('models/textureCards/pvp_arrow')
     self.holder = holder
     hasTeams = holder.hasTeams()
     self.borderOne = BorderFrame.BorderFrame(
         relief=None,
         frameSize=(-(PiratesGuiGlobals.PVPCompletePageWidth) *
                    0.33000000000000002,
                    PiratesGuiGlobals.PVPCompletePageWidth *
                    0.33000000000000002,
                    PiratesGuiGlobals.PVPCompletePageHeight * 0.5 -
                    0.10000000000000001 -
                    (PiratesGuiGlobals.TMCompletePageHeight / 16.0) *
                    len(holder.getItemList(1)),
                    PiratesGuiGlobals.PVPCompletePageHeight * 0.5),
         modelName='pir_m_gui_frm_subframe',
         imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.borderOneSecondLayer = BorderFrame.BorderFrame(
         parent=self.borderOne,
         relief=None,
         text='',
         text_scale=0.074999999999999997,
         text_fg=PVPGlobals.getTeamColor(1),
         text_pos=(-0.65000000000000002, 0.64000000000000001),
         frameSize=(-(PiratesGuiGlobals.PVPCompletePageWidth) *
                    0.33000000000000002,
                    PiratesGuiGlobals.PVPCompletePageWidth *
                    0.33000000000000002,
                    PiratesGuiGlobals.PVPCompletePageHeight * 0.5 -
                    0.10000000000000001 -
                    (PiratesGuiGlobals.TMCompletePageHeight / 16.0) *
                    len(holder.getItemList(1)),
                    PiratesGuiGlobals.PVPCompletePageHeight * 0.5),
         modelName='pir_m_gui_frm_subframe',
         imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
     self.borderOne.setPos(0.0625, 0, -0.10000000000000001)
     if hasTeams:
         self.borderOneSecondLayer['text'] = PLocalizer.PVPTeamName % 1
         self.one = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.2,
                               PiratesGuiGlobals.PVPCompletePageHeight,
                               holder,
                               1,
                               sortOrder=2)
         self.one.setPos(-0.5, 0, -0.84999999999999998)
     else:
         self.one = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.0,
                               PiratesGuiGlobals.PVPCompletePageHeight,
                               holder,
                               1,
                               sortOrder=2)
         self.one.setPos(-0.73999999999999999, 0, -0.84999999999999998)
     self.borderOne.hide()
     self.one.hide()
     if hasTeams:
         self.borderTwo = BorderFrame.BorderFrame(
             relief=None,
             frameSize=(-(PiratesGuiGlobals.PVPCompletePageWidth) *
                        0.33000000000000002,
                        PiratesGuiGlobals.PVPCompletePageWidth *
                        0.33000000000000002,
                        PiratesGuiGlobals.PVPCompletePageHeight * 0.5 -
                        0.10000000000000001 -
                        (PiratesGuiGlobals.TMCompletePageHeight / 16.0) *
                        len(holder.getItemList(2)),
                        PiratesGuiGlobals.PVPCompletePageHeight * 0.5),
             modelName='pir_m_gui_frm_subframe',
             imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
         self.borderTwoSecondLayer = BorderFrame.BorderFrame(
             parent=self.borderTwo,
             relief=None,
             text=PLocalizer.PVPTeamName % 2,
             text_scale=0.074999999999999997,
             text_fg=PVPGlobals.getTeamColor(2),
             text_pos=(-0.65000000000000002, 0.64000000000000001),
             frameSize=(-(PiratesGuiGlobals.PVPCompletePageWidth) *
                        0.33000000000000002,
                        PiratesGuiGlobals.PVPCompletePageWidth *
                        0.33000000000000002,
                        PiratesGuiGlobals.PVPCompletePageHeight * 0.5 -
                        0.10000000000000001 -
                        (PiratesGuiGlobals.TMCompletePageHeight / 16.0) *
                        len(holder.getItemList(2)),
                        PiratesGuiGlobals.PVPCompletePageHeight * 0.5),
             modelName='pir_m_gui_frm_subframe',
             imageColorScale=VBase4(0.75, 0.75, 0.90000000000000002, 0.75))
         self.two = ScoreFrame(PiratesGuiGlobals.PVPCompletePageWidth - 1.2,
                               PiratesGuiGlobals.PVPCompletePageHeight,
                               holder,
                               2,
                               sortOrder=2)
         self.borderTwo.setPos(
             0.0625, 0,
             -0.25 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) *
             len(holder.getItemList(1)))
         self.two.setPos(
             -0.5, 0,
             -1.0 - (PiratesGuiGlobals.TMCompletePageHeight / 16.0) *
             len(holder.getItemList(1)))
         self.borderTwo.hide()
         self.two.hide()
     else:
         self.borderTwo = None
         self.two = None
Ejemplo n.º 20
0
 def getTeamStats(self, team):
     teams = { }
     displayStats = []
     for (playerId, stats) in self.stats.items():
         if playerId not in self.names:
             continue
         
         playerName = self.names[playerId]
         playerTeam = self.teams[playerId]
         if team and playerTeam != team:
             continue
         
         if not teams.get(playerTeam):
             teams[playerTeam] = []
         
         playerStats = []
         for stat in self.getColumnStats():
             playerStats.append([
                 PVPGlobals.statText[stat],
                 str(stats[stat])])
         
         if playerId == localAvatar.doId:
             playerColor = (1, 1, 1, 1)
         else:
             playerColor = PVPGlobals.getTeamColor(playerTeam)
         teams[playerTeam].append([
             playerName,
             playerStats,
             [
                 'color',
                 playerColor]])
     
     if team:
         if not teams.has_key(team):
             return displayStats
         
         teamStats = teams[team]
         teamTotals = []
         for stat in self.getColumnStats():
             teamTotals.append([
                 PVPGlobals.statText[stat],
                 0])
         
         for (playerName, playerStats, color) in teamStats:
             for i in range(len(playerStats)):
                 teamTotals[i][1] = str(int(teamTotals[i][1]) + int(playerStats[i][1]))
             
         
         teamStat = [
             PLocalizer.PVPTeamTotal,
             teamTotals,
             [
                 'color',
                 PVPGlobals.getTeamColor(team)]]
         teamStats = self.sortStats(teamStats)
         teamStats.append(teamStat)
         displayStats = teamStats
     else:
         for (team, teamStats) in teams.items():
             teamTotals = []
             for stat in self.getColumnStats():
                 teamTotals.append([
                     PVPGlobals.statText[stat],
                     0])
             
             for (playerName, playerStats, color) in teamStats:
                 for i in range(len(playerStats)):
                     teamTotals[i][1] = str(int(teamTotals[i][1]) + int(playerStats[i][1]))
                 
             
             teamStats = self.sortStats(teamStats)
             displayStats += teamStats
         
     displayStats.insert(0, self.getColumnLabels())
     return displayStats