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

Go to the documentation of this file.

''' 
        Anoria (c) Gsk 2010
'''


import BigWorld
import ResMgr

''' As far as I can tell this code (which is based on code right at the very end of FD Avatar.py)
is probably deprecated and not used in FD anymore. Instead the set_AvatarModel() stuff starting around
l.714 seems to be the current code. 
We use this for now anyway since its simple and seems to work well. Probably going to have to replace it 
once we go into customizable Avatar Models though '''

class AvatarModelManager():
        ''' This is the AvatarModelManager Singleton
                it reads and parses the master model definition .xml files from scripts/client/data
                and makes functionality related to those available
        '''
        
        __instance = None
        
        def __init__(self):
                if AvatarModelManager.__instance: return
                AvatarModelManager.__instance=self;
                
                self.modelPresets = None
                self.AvatarModels = None
                self.buildAvatarModels()

        # This function loads and parses the XML file describing all the
        # ways in which player supermodels can be constructed,
        # and stores the result in the global variable AvatarModels.
        def buildAvatarModels(self, cclass = None ):
                self.AvatarModels = ResMgr.openSection( "scripts/client/data/AvatarModels.xml" )
        
                good = 0
                try:
                        amp = ResMgr.openSection( "scripts/client/data/AvatarModelPresets.xml" )
                        if not cclass or not amp.has_key( cclass ):     cclass = "presets"
                        self.modelPresets = eval( amp.readString( cclass ) )
                        good = (type(self.modelPresets) == type([]))
                except:
                        pass
                if not good: self.modelPresets = []


        # Return a model from the given model number
        def makeModel(self, num, oldModel ):
                #print "makeModel(",num,")"
        
                mnames = []
                dspecs = {}
                # use the bottom n values of num at each stage
        
                # first decide which skeleton
                skelsec = self.AvatarModels
                skelcount = len(skelsec)
                skelid = num % skelcount
                num = (num-skelid) / skelcount
                skel = self.AvatarModels.values()[ skelid ]
        
                #print " skelid", skelid
        
                # now for each of the parts:
                for partsec in skel.values():
        
                        # decide which model variation to use
                        partcount = len(partsec)
                        partid = num % partcount
                        num = (num-partid) / partcount
                        part = partsec.values()[ partid ]
                        mnames.append( part.asString )
        
                        #print "  part", partsec.name, partid
        
                        # and for each of its matters:
                        for tintsec in part.values():
        
                                # decide what tint to use
                                tintcount = len(tintsec) + 1
                                tintid = num % tintcount
                                num = (num-tintid) / tintcount
                                if tintid > 0:
                                        tint = tintsec.keys()[ tintid-1 ]
                                else:
                                        tint = ""
                                dspecs[ tintsec.name ] = tint
        
                                #print "   tint", tintsec.name, tintid
        
                # make the model
                #print "mnames: ", mnames
                if oldModel != None and oldModel.sources == tuple(mnames):
                        m = oldModel
                else:
                        m = BigWorld.Model( *mnames )
        
                # apply any dyes
                #print "dspecs: ", dspecs
                for dye in dspecs.items():
                        setattr( m, dye[0], dye[1] )
        
                # and that's it
                return m
        
        
        # Return a tree describing all model combinations
        # A node in the tree is a list of choices which must be made at that
        # node. The elements of the list are either tuples of more tree nodes
        # or a number that must be selected.
        def treeModelNumbers(self):
        
                tr = []                 # tuple => choose one of these
                for skel in self.AvatarModels.values():
                        ts = []                 # list => choose in each of these
                        for partsec in skel.values():
                                tps = []                # tuple => choose one of these
                                for part in partsec.values():
                                        tp = []                 # list => choose in each of these
                                        for tintsec in part.values():
                                                tt = len(tintsec)+1     # int => choose one of these
                                                tp.append( tt )
                                        tps.append( tp )
                                ts.append( tuple(tps) )
                        tr.append( ts )
                return [tuple(tr)]
        
        
        # Return a list of all valid model numbers
        def listModelNumbers(self):
                return self.listModelNode(self.treeModelNumbers())
        
        # Return a list of valid model numbers from this node
        def listModelNode(self, node ):
                if node == []: return [0]
        
                b = []
        
                # go over all the elts in the list, and add them to b
                for elt in node:
                        l = []
        
                        # see if it's a tuple
                        if type(elt) == type((0,)):
                                lenelt = len(elt)
                                for ei in range(lenelt):
                                        for i in self.listModelNode( elt[ei] ):
                                                l.append( ei + lenelt * i )
                        # it must be an integer
                        else:
                                l = range(elt)
        
                        b.append( l )
        
                # now flatten our list of numbers, by zipping it up
                nums = [0]
                for i in range( len(b)-1, -1, -1 ):
                        nn = []
                        for j in b[i]:
                                for val in nums:
                                        nn.append( j + len(b[i]) * val )
                        nums = nn
        
                return nums
        
AvatarModelManager=AvatarModelManager()