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

Go to the documentation of this file.

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

# -----------------------------------------------------------------------------
# Avatar Cell Implementation
# -----------------------------------------------------------------------------

import BigWorld

from Actor import Actor
from config import consts 
from config import state
from config import event

from Resources import ItemDef

import Anoria

class Avatar(BigWorld.Entity, Actor):

        def __init__(self):
                BigWorld.Entity.__init__(self)
                Actor.__init__(self)
                self.isPlayer = True  # override default from Mob
                self.name = "%s.%d" % (self.name, self.id)
                
                # our event processing plugins
                self.addEventProc(event.UNDER_ATTACK, self.eventUnderAttack)

                # for now just equip a hard coded weapon on slot 0 for testing
                weapon = ItemDef()
                weapon.id = 'dev-test-sword-14-3000'
                weapon.dmg = 14
                weapon.dly = 3000
                self.combatResolver.equipWeapon(weapon, 0)
                
                
        # -------------------------------------------------------------------------
        # Section: Callbacks
        # -------------------------------------------------------------------------
                
        # callback for the Timer started in Actor.__init__
        # this is basically Avatar's brain
        def onTimer(self, timerId, userData):
                ''' onTimer() is the regular update tick processor for Avatar. Think of it as Avatar's brain
                        @param: timerId several timers can be started with differing timerIds
                        @param: userData can be used to pass in info from the function starting the timer '''
                Actor.onTimer(self, timerId, userData)
                if userData != 0: return  # the code below only processes timer 0
                
                if self.states[state.STATE_COMBAT] == state.S_COMBAT_ON:
                        #  Combat updates: first check whether we still have a valid target
                        if self.targetId != None:           # did we have something targeted?
                                target = self.getTargetEntity() # does that object still exist?
                                if target == None:              # nope
                                        self.targetLost()           # this will turn of auto attack mode if on but not cancel combat mode!
                                else:
                                        dist = self.position.distTo(target.position)
                                        inRange = consts.MELEE_MAX_DISTANCE - dist > 0.0
                                        if not inRange:
                                                if self.states[state.STATE_ATTACK] == state.S_ATTACK_ON:
                                                        self.pauseAutoattack() 
                                        elif self.states[state.STATE_ATTACK] == state.S_ATTACK_PAUSED:
                                                self.pauseAutoattack(restart=True) 
                                                
                        # test whether we can cancel combat mode: no auto attack and no one holds aggro on us
                        if not self.states[state.STATE_ATTACK] == state.S_ATTACK_ON and not self.haveAggro():
                                self.exitCombat()
                else:
                        #       - health & power regen only if we are not "in combat"
                        self.doHealthRegen()

                # drive the combat resolver: note that this currently must be ticked on 
                # each loop or else it'll get confused. Need to implement a re-init call for its timer
                self.combatResolver.update()

        
        # -------------------------------------------------------------------------
        # Section: RPC
        # -------------------------------------------------------------------------

        def rpc_setTarget(self, id, entityId):
                ''' rpc_setTarget is called by the client whenever it targets some entity
                        @param: id is the id of the calling client entity
                        @param: entityId is the id of the entity being targeted '''
                # MFU: ADD validation here! This comes from the client! Cant just blindly accept the ID
                if entityId != 0:
                        if entityId != self.targetId:
                                print 'Avatar_%d.rpc_setTarget() setting target, Id=%d' % (self.id, entityId)
                                self.setTarget(entityId)
                else:
                        self.targetId = None    
                        self.stopAutoattack()        # no auto attack mode without a target
                
        # client calls this when the player toggles one of the AutoAttack controls (key, button , whatever)
        def rpcAutoAttackToggle(self, id):
                '''this function is a toggle: calling it when already auto attacking 
                        will turn auto attack off again 
                        @param: id is the id of the client entity making the call'''
                
                print 'Avatar_%d.rpcAutoAttackToggle(): from Id=%d' % (self.id, id)
                if self.states[state.STATE_ATTACK] != state.S_ATTACK_OFF:
                        self.stopAutoattack()
                else:
                        self.beginAutoAttack()

        def rpcSay( self, id, message ):
                if self.id == id:
                        text = "%s says: '%s'" % (self.name, message)
                        print text
                        self.otherClients.rpc_chatText(text, 1)
        
        # -------------------------------------------------------------------------
        # Section: combat
        # -------------------------------------------------------------------------

        def beginAutoAttack(self):
                # do we have a target?
                target = self.getTargetEntity()
                if target == None: 
                        self.client.rpc_printString(4, consts.MELEE_COMBAT_CHANNEL_ID)
                        return
                # is it not ourselves?
                if target == self: 
                        self.client.rpc_printString(10, consts.MELEE_COMBAT_CHANNEL_ID)
                        return
                # is it in melee range?
                dist = self.position.distTo(target.position)
                inRange = consts.MELEE_MAX_DISTANCE - dist >= 0.0
                print 'Avatar_%d.initCombat(): target dist=%.3f, inRange=%s' % (self.id, dist, inRange)
                if not inRange:
                        self.client.rpc_printString(3, consts.MELEE_COMBAT_CHANNEL_ID)
                        return
                
                # ok: GO
                self.enterCombat()
                self.allClients.rpcChangeState(state.STATE_ATTACK, state.S_ATTACK_ON)

        def targetLost(self):
                Actor.targetLost(self)        # call down to base class first
                self.client.rpcTargetLost()   # tell the client

                
        # -------------------------------------------------------------------------
        # Section: Game Event Processing
        # -------------------------------------------------------------------------
                
                
        # should better be called eventAggro actually
        def eventUnderAttack(self, attackerId, eventValue):
                ''' eventUnderAttack is received when ever anything hostile is done to this Actor.
                    @param: attackerId is the entity id of the hostile entity
                    @param: eventValue is the type of hostile activity '''

                print "Avatar_%d.eventUnderAttack(): attackerId=%d, eventValue=[%d]%s" \
                      % (self.id, attackerId, eventValue, event.ATTACK_EVENTS[eventValue])

                self.aggroFromEntity(attackerId)  # add to aggro list

                if not self.states[state.STATE_COMBAT] == state.S_COMBAT_ON:
                        self.enterCombat()   # dont pass in attackerID, we dont want to auto-target for the player