E:/project/Anoria2/bigworld/anoria/res/scripts/base/Avatar.py

Go to the documentation of this file.

''' 
        base.Avatar implements the base ("proxy") component for player Avatars
        Anything that is not related to the world geometry or requires spatial relationship info
        is handled on base: hitpoints, proficiencies, stats & skills etc.
        
        Anoria (c) Gsk 2010
'''


import BigWorld


import Anoria
from Actor import Actor

from Resources import ResourceDB as RDB
from config import consts
from config import event
from config import request

# Must derive from BigWorld.Proxy instead of BigWorld.Base if this entity type
# is to be controlled by the player.
class Avatar(BigWorld.Proxy, Actor):

        def __init__( self ):
                print "Avatar_%d initializing base component" % (self.id)
                
                BigWorld.Proxy.__init__( self )
                Actor.__init__(self)
                self.requestProc = { request.REQ_POINTS_ASSIGN:self.doProficienciesAssign }
                self.addEventProc(event.ENTITY_KILL, self.eventEntityKill)

                # NOTE that AVATAR, unlike MOB, spawns its cell once the client connects 
                # in onEntitiesEnabled() below


        def awardXp(self, Xp):
                # self.Xp = self.Xp + Xp
                self.Xp += Xp
                nextRankXp = consts.XPTABLE[self.totalProficiencyPoints]
                xpPercent = ((float(self.Xp)/float(nextRankXp))*100.0)
                if xpPercent >= 100:
                        print "Avatar.awardXp() Avatar %d gained a proficiency point!" % (self.id)
                        self.client.rpcProcessEvent(self.id, event.PROFICIENCY_POINT_GAIN, 0)
                        self.totalProficiencyPoints += 1
                        self.unspentProficiencyPoints += 1
                        xpPercent = 0
                         
                return xpPercent
        
        # -------------------------------------------------------------------------
        # Section: Events
        # -------------------------------------------------------------------------
        
        # Event is sent by Mob cell entities 
        def eventEntityKill(self, sourceId, Xp):
                print "Avatar.entityKillEvent() Xp:", Xp
                xpPercent = self.awardXp(Xp)
                self.client.rpcProcessEvent(sourceId, event.ENTITY_KILL, xpPercent)

        
        # -------------------------------------------------------------------------
        # Section: Client Processing Requests
        # -------------------------------------------------------------------------
                
        def assignProficiencyPoints(self, listIndex, points):
                ''' assign a number of points to a proficiency, do all required effects processing and housekeeping
                @param listIndex determines the proficiency to assign to
                @param points is the number of proficiency points to assign '''

                proficiencyName = consts.PROFICIENCY_CODES[listIndex]
                # print "assignProficiencyPoints() %s %d" % (proficiencyName, points)
                
                # points assignment
                self.proficienciesList[listIndex] += points
                rank = self.proficienciesList[listIndex]
                self.unspentProficiencyPoints -= points
                # effects processing
                try:
                        pdef = RDB.proficiencies[proficiencyName]
                except:
                        print 'undefined proficiency, cant do effects processing ', proficiencyName
                        return
                
                try:
                        effectId = pdef.effects[rank]
                except:
                        print ' no effect defined for proficiency %s at rank %d  ' % (proficiencyName, rank)
                        return
                        
                self.cell.rpcProcessStringEvent(self.id, event.APPLY_STATS_EFFECT, effectId)

                
        # player sends an updated proficienciesList: validate and asssign if ok
        def doProficienciesAssign(self, proficienciesList):
                ''' this is a client exposed function: very thoroughly validate the input list!
                @param proficieniesList: client side list containing all edits (=values > 0)'''
                # print proficienciesList
                # Input validation
                # 
                print 'doProficienciesAssign() ', proficienciesList
                
                # check list len
                if len(proficienciesList) != consts.NUM_PROFICIENCIES:
                        print "POTENTIAL TAMPERING: doProficienciesAssign() invalid proficiency list length from avatar id=%d" % (self.id)
                        return

                # check points total
                listTotalPoints=0
                for n in proficienciesList:
                        listTotalPoints += n

                if listTotalPoints > self.unspentProficiencyPoints:
                        print "POTENTIAL TAMPERING: doProficienciesAssign() invalid proficiency edit list points total from avatar id=%d" % (self.id)
                        return
                        
                # initial validation ok: do the assignments
                # how many ranks can we assign to any given proficiency currently?
                maxRanks = 2 + self.totalProficiencyPoints/4
                i = -1
                for n in proficienciesList:
                        i += 1
                        if n > 0:
                                if self.proficienciesList[i]+n <= maxRanks:
                                        self.assignProficiencyPoints(i, n)
                                        self.client.rpc_chatText("Proficiencies assigned.", 0)
                                else:   
                                        print "POTENTIAL TAMPERING: doProficienciesAssign() invalid points/proficiency from avatar id=%d" % (self.id)
                                                
        
        
        def rpcClientRequest(self, reqCode, reqParams):
                print "Avatar.rpcClientRequest(): reqType=%s" % (request.REQUESTS[reqCode])
                # call the event processor for this event (if any)
                # print len(self.eventProc)
                func = None
                try:
                        func = self.requestProc[reqCode]        
                except:
                        print 'ERROR in rpcClientRequest(): no handler for %s defined' % (request.REQUESTS[reqCode]) 

                if func != None: func(reqParams)
        
        # -------------------------------------------------------------------------
        # Section: CALLBACKS
        # -------------------------------------------------------------------------

        def onLogOnAttempt(self, ip, port, password):
                print "Avatar.onLogOnAttempt(): ip=%s, port=%s, password=%s" % (ip, port, password)
                return BigWorld.LOG_ON_REJECT
        
        def onEntitiesEnabled(self):
                ''' called once the client requests to receive cell updates: i.e the client is "online" '''
                
                ''' Note: self.cellData is automatically initialised by the System upon base creation 
                        - per default its a dictionary initialised with the values from the entity.def file
                        - we just overide position here '''
                
                self.isPlayer = True      # we are the player
                self.cellData[ "position" ] = ( 0.0 , 105.43, -38.9 )
                self.cellData["modelName" ] = ""  # hard code model name for now: player avatar uses the number system below
                self.cellData["modelNumber" ] = 1 # hard code a model number for now (this is the ranger model in the old system)
                self.createInDefaultSpace()

                # subscribe to default chat channels: 0=system 1=world_announce
                # chatMgr = BigWorld.globalBases['ChatManager']
                # chatMgr.subscribe(self, 0)
                # chatMgr.subscribe(self, 1)
                Anoria.SystemChatChannel.subscribe(self)
                self.client.rpc_chatText(RDB.strings[0], consts.SYSTEM_CHANNEL_ID)
                self.client.rpc_chatText("This currently is largely a tech preview with very little actual game play.", consts.SYSTEM_CHANNEL_ID)
                self.client.rpc_chatText("You can look around a little using standard mouse-look WSAD controls.", consts.SYSTEM_CHANNEL_ID)
                self.client.rpc_chatText("ENTER opens this chat console. Attack creatures or players by pressing [Q].", consts.SYSTEM_CHANNEL_ID)
                self.client.rpc_chatText("You will gain experience and proficiency points by killing creatures.", consts.SYSTEM_CHANNEL_ID)
                self.client.rpc_chatText("Assign the gained points ([P] key) to improve you base stats.", consts.SYSTEM_CHANNEL_ID)
                
        
        def onClientDeath( self ):
                " Client disconnect handler "
                
                ''' NOTE: BigWorld disconnect sequence:
                        - BigWorld calls proxy.onCientDeath()
                        - we call self.destroyCellEntity()
                        - BigWorld calls base.onLoseCell() (proxy inherits from base) 
                '''
                # unsubscribe chats
                Anoria.SystemChatChannel.unsubscribe(self)
                
                # When the client disconnects, we want to make sure our cell entity
                # doesn't hang around. 
                ''' gs: does this cause onLoseCell() further below to be called subsequently? (think so) ''' 
                self.destroyCellEntity()

        def onGetCell(self):
                ''' called once our cell entity has been successfully created '''
                print "Avatar.onGetCell()"
                
        def onLoseCell( self ):
                ''' called once our cell entity has been destroyed '''
                print "Avatar.onLoseCell(): cleaning up avatar"
                
                # NOTE that FD registers all entities with a respawn manager (RSM) at this point. Presumably this is
                # to cover for disaster recover scenarios when a cell app dies and we need to be able to restore world state 
                # transparently after restart.
                # For now we just plain destroy ourselves when we loose the cell
                self.destroy(deleteFromDB=False, writeToDB=True)

        def cb_writeToDB(self, success, base):
                print "Avatar.cb_writeToDB(): success=%s" % (success)