E:/project/Anoria2/bigworld/anoria/res/scripts/client/AnGUI/ProficienciesWindow.py

Go to the documentation of this file.

''' 
        ProficienciesWindow()
        
        implements the proficiencies interface for players: display current points distribution and totals
        and facilitate assignment of unspent points
        
        Anoria (c) Gsk 2010
'''

import BigWorld 
import GUI

import AnGUI
from Listener import Listener
from config import request
from config.consts import PROFICIENCY_CODES

class ProficienciesWindow(Listener):
        
        def __init__(self):
                Listener.__init__(self, self.__class__)
                self.Gui = GUI.load("gui/proficiencies.gui")
                self.totalPoints = 0
                self.unspentPoints = 0
                self.proficienciesList = []
                
                # intermediate edit state
                self.edits = False
                self.unspentPointsEdit = 0
                self.proficienciesListEdit = []
                                
                self.choices = {} # component indices of clickable children keyed by name(=proficiency entries)
                self.setListen()
                
        def setListen(self):
                ''' listen to all our child components that can generate AnGUI events '''
                index = 0
                for name, child in self.Gui.children:
                        child.script.name = name # set script name (=guiEvent name) to child component name
                        if hasattr(child.script, 'canActivate'):
                                if child.script.canActivate:
                                        AnGUI.service.addListener(self, AnGUI.GuiEvent(child.script.name, 'ACTIVATE'))
                                        if name[0:2] == 'p_':
                                                self.choices[name] = index
                        index += 1
                        
        def updateTitle(self, edit=False):
                ''' update the points display in the window title bar '''
                if edit:
                        unspentPoints = self.unspentPointsEdit
                else:
                        unspentPoints = self.unspentPoints
                        
                self.Gui.title.text.text = "Proficiencies %d/%d" % (unspentPoints, self.totalPoints)

        def resetEdits(self):
                ''' reset all changes the player has done in the edit state '''
                if not self.edits: return
                self.edits = True 
                self.updateProficiencies(self.proficienciesList)
                self.proficienciesListEdit = self.proficienciesList[:]
                self.unspentPointsEdit = self.unspentPoints
                self.updateTitle()
                self.setFocus(True)
                
                
        def handleGuiEvent(self, guiEvent):
                #print "ProficienciesWindow.handleGuiEvent() eventName=%s eventAction=%s" % (guiEvent.name, guiEvent.action) 
                name = guiEvent.name
                if name == 'button_accept':
                        self.setVisible(False)
                        self.unspentPoints = self.unspentPointsEdit
                        player = BigWorld.player()
                        player.unspentProficiencyPoints = self.unspentPoints
                        # we send a list with only the edits to the server, extract them from the edited proficiencies list
                        list = []
                        i = 0
                        # print self.proficienciesListEdit
                        for n in self.proficienciesListEdit:
                                delta = n - self.proficienciesList[i]
                                # print n, self.proficienciesList[i], delta
                                i += 1
                                if delta > 0:
                                        list.append(delta)
                                else:
                                        list.append(0)
                        # print list
                        self.proficienciesList = self.proficienciesListEdit[:]
                        player.base.rpcClientRequest(request.REQ_POINTS_ASSIGN, list)
                elif name == 'button_cancel':
                        self.resetEdits()        # reset edit state
                        self.setVisible(False)
                elif name in self.choices.keys():
                        self.doPointAssign(name)

        def doPointAssign(self, proficiencyName):
                if not self.unspentPointsEdit > 0: return
                self.edits = True
                proficiencyCode = PROFICIENCY_CODES.index(proficiencyName)
                self.proficienciesListEdit[proficiencyCode] += 1
                self.unspentPointsEdit -= 1
                self.setFocus(True) # update clickable states
                self.updateTitle(edit=True)
                index = self.choices[proficiencyName]
                component = self.Gui.children[index][1]
                component.text.text = '%d/5' % (self.proficienciesListEdit[proficiencyCode])
                
        def updateProficiencies(self, proficienciesList):
                ''' update all the proficieny entries in the window to match the passed in proficienciesList '''
                i=0
                for val in proficienciesList:
                        name = PROFICIENCY_CODES[i]
                        componentIndex = self.choices[name]
                        component = self.Gui.children[componentIndex][1]
                        component.text.text = '%d/5' % (val)
                        i += 1
                        
        def setPoints(self, unspent, total, list=None):
                ''' used by avatar to update us '''
                self.unspentPoints = unspent
                self.unspentPointsEdit = unspent
                self.totalPoints = total
                if list != None:
                        self.proficienciesList = list[:]      # slice copy
                        self.proficienciesListEdit = list[:]  # intermediate list for editing
                self.updateTitle()
                self.setFocus(True)
                        
        def setFocus(self, state):
                ''' @param state: enable or disable focus of child components
                        @return None
                        
                        enable  or disable child components' highlight and clickable states
                    this finds all clickable components and enables those that would be valid for the 
                        player to select given his current proficiency point numbers (unspent/total) ''' 

                # no points left? switch all off
                if not self.unspentPointsEdit > 0:
                        state = False
                         
                # how many ranks can we assign to any given proficiency currently?
                maxRanks = 2 + self.totalPoints/4

                for name, child in self.Gui.children:
                        if name in PROFICIENCY_CODES:
                                proficiencyCode = PROFICIENCY_CODES.index(name)
                        else:
                                continue

                        # how many ranks in the proficiency in question do we have currently?
                        curRanks = self.proficienciesListEdit[proficiencyCode]
                        if hasattr(child.script, 'canActivate'):
                                if child.script.canActivate:
                                        if curRanks < maxRanks:
                                                child.focus = state
                                        else:
                                                child.focus = False
                        if hasattr(child.script, 'canHighlight'):
                                if child.script.canHighlight:
                                        if curRanks < maxRanks:
                                                child.crossFocus = state
                                        else:
                                                child.crossFocus = False
        

        def toggleActive(self):
                if self.Gui.visible:
                        self.setVisible(False)
                        self.resetEdits()
                else:
                        self.setVisible(True)
                        
        def setVisible(self, state):
                self.Gui.visible = state
                        
        def setXpBar(self, value):
                clipper = self.Gui.xp_bar.clipper
                clipper.value = value