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

Go to the documentation of this file.

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


import BigWorld
import time
import math

from Resources import ResourceDB as RDB
import Stats

from gamesys.Combat import CombatResolver
from gamesys.ProcTimer import ProcTimer

from config.consts import *
from config import state
from config import event

                
class Actor(Stats.StatsManager):

        def __init__(self):
                print "Actor_%d initializing cell component..." % (self.id)
                Stats.StatsManager.__init__(self, isServer=True)
                # let the StatsManager setup its internal data; this is decoupled from __init__
                # because the client uses the class too and has to init the data separately from the object.__init__
                self.initStatsData()   
                
                self.aggroFromList = [] # list of entities we have aggro FROM currently (these hold aggro on US)
                self.aggroOnList = []   # list of entities we have aggro ON currently (we hold aggro on THEM)
                 
                self.combatResolver = CombatResolver(self.id, self)
                delta_t = 1.0 / GAME_UPDATE_RATE   # rate from config 
                self.addTimer(delta_t, delta_t, 0) # driver for all our periodic updates
                
                self.states = [state.S_STANCE_IDLE, state.S_MOVE_NONE, state.S_COMBAT_OFF, state.S_ATTACK_OFF]
                
                self.isPlayer = False     # assume we are not a player
                self.targetId = None
                
                self.eventProc = { }
                self.timeLastHitReceived = 0
                                                
                self.addEventProc(event.APPLY_STATS_EFFECT, self.applyEffect) 
                self.addEventProc(event.AGGRO_DROPPED, self.eventAggroDropped)

        # -------------------------------------------------------------------------
        # Section: Aggro Management
        # -------------------------------------------------------------------------
        
        # Aggro ON
        def aggroOn(self, entityId):
                if not entityId in self.aggroOnList:
                        self.aggroOnList.append(entityId)
                        print "Actor_%d has aggroed on entity %d" % (self.id, entityId)
                        print "aggroOnList: ", self.aggroFromList

        def deAggroOn(self, entityId):
                ''' deAggroOn removes the given entityId to the aggroOn list, means that dont hold aggro on them anymore
                        @param: entityId the id of the entity to remove from the aggroOn list '''
                if entityId in self.aggroOnList:
                        index = self.aggroOnList.index(entityId)
                        del self.aggroOnList[index]
                        print "Actor_%d removed entity %d from aggroOnList" % (self.id, entityId)
                        print "aggroFromList: ", self.aggroFromList

        def haveAggroOn(self):
                ''' test whether we have any aggro from anyone
                        @return: True of False test result '''
                if len(self.aggroOnList) > 0:
                        return True
                return False
        
        # Aggro FROM
        def aggroFromEntity(self, entityId):
                ''' aggroFromEntity adds the given entityId to the aggro list. This signifies that this entity has aggroed us, 
                        we cannot leave combat mode as long as we have any aggro. 
                        @param: entityId the id of the entity to add to the aggro list '''
                if not entityId in self.aggroFromList:
                        self.aggroFromList.append(entityId)
                        print "Actor_%d has aquired aggro from entity %d" % (self.id, entityId)
                        print "aggroFromList: ", self.aggroFromList

        def deAggroFrom(self, entityId):
                ''' deAggroFrom removes the given entityId from the aggroFrom list, means that entity does not hold aggro on us anymore
                        @param: entityId the id of the entity to remove from the aggro list '''
                if entityId in self.aggroFromList:
                        index = self.aggroFromList.index(entityId)
                        del self.aggroFromList[index]
                        print "Actor_%d removed entity %d from aggroFromList" % (self.id, entityId)
                        print "aggroFromList: ", self.aggroFromList

        def haveAggroFrom(self, entityId):
                ''' test whether we have aggro on a given entity
                        @param: entityId the id of the entity to test against the list 
                        @return: True of False test result '''
                if entityId in self.aggroFromList:
                        return True
                
        def haveAggro(self):
                ''' test whether we have any aggro from anyone
                        @return: True of False test result '''
                if len(self.aggroFromList) > 0:
                        return True
                return False
                
                
        # -------------------------------------------------------------------------
        # Section: Events
        # -------------------------------------------------------------------------

        def eventAggroDropped(self, sourceId, eventValue):
                self.deAggroFrom(sourceId)

        def applyEffect(self, sourceId, effectId):
                ''' the sole function of this one is to remove the sourceId from the rpcEvent call '''
                self.applyStatsEffect(effectId)
                
        def addEventProc(self, eventId, proc):
                # print "adding eventProc for event:%d" % (eventId), proc
                self.eventProc[eventId]=proc

        # -------------------------------------------------------------------------
        # Section: Misc
        # -------------------------------------------------------------------------

        def getTargetEntity(self):
                entity = None
                try:
                        entity = BigWorld.entities[self.targetId]
                except:
                        return None
                
                return entity
        
        
        # -------------------------------------------------------------------------
        # Section: CALLBACKS
        # -------------------------------------------------------------------------

        # callback for the Timer started in Actor.__init__
        # overridden by: Mob, Avatar
        def onTimer(self, timerId, userData):
                # timer 1 is the timer set by self.Die() in order to trigger entity clean up after
                # giving the client enough time to play the death sequence animations 
                if userData == 1:
                        self.destroy()

                
        # combat resolver callback
        def onWeaponAttackPerformed(self, hitType, dmg):
                ''' callback for the combat resolver  
                        called whenever one of the equipped weapons has performed a single attack'''
                # inform all clients in our AOI so that they can play animations etc
                self.allClients.rpcMeleeAttack(self.targetId, hitType, dmg)
                if hitType in [HIT_TYPE_NORMAL, HIT_TYPE_CRIT, HIT_TYPE_CRUSH]:
                       self.doDamage(hitType, dmg)
        
        # we are being destroyed:
        def onDestroy(self):
                pass

        # -------------------------------------------------------------------------
        # Section: Movement & Facing 
        # -------------------------------------------------------------------------
        
        # This method faces towards a position.
        # Note: direction changes get relayed to clients automatically
        def facePosition(self, pos):
                vector = (pos[0] - self.position[0], 0, pos[2] - self.position[2])
                yaw = math.atan2(vector[0], vector[2])
                # print "Actor.facePosition() setting yaw: name=%s, old=%.2f, new=%.2f" % (self.name, self.direction[2], yaw)
                self.direction = (0, 0, yaw)

        # -------------------------------------------------------------------------
        # Section: Combat, HP handling - Damage & Regeneration
        # -------------------------------------------------------------------------

        # called by the combat resolver on every successful attack
        def doDamage(self, hitType, damage):
                target = self.getTargetEntity()
                if target != None:
                        target.rpcReceiveDamage(damage, self.id) 

        def doHealthRegen(self):
                hp = self.characterStats.HP
                if hp.curValue < hp.maxValue and not self.states[state.STATE_COMBAT] == state.S_COMBAT_ON:
                        increment = hp.maxValue * HP_REGEN_FACTOR
                        # print "doHealthRegen(): %s hp regen increment=%f" % (self.name, increment)
                        hp.curValue += increment
                        self.updateHealthPercent()
                
        def updateHealthPercent(self):
                '''     update our public healthPercent property: this will trigger an update to all clients
                and cells holding a ghost of us since healthPercent is flagged ALL_CLIENTS and thus available to everyone
                as opposed to the character stats themselves '''
                hp = self.characterStats.HP
                self.healthPercent = ((float(hp.curValue)/float(hp.maxValue))*100.0) 

        def enterCombat(self, attackerId=None):
                ''' enterCombat is called when an Actor enters into combat mode
                    @param: attackerId is an optional parameter, if not None it indicates that we are entering into 
                    combat mode because someone else (identified by attackerId) attacked us. In this case we'll
                    automatically target the attacker '''
                   
                print "Actor_%d.enterCombat()" % (self.id)

                self.timeLastHitReceived = time.time()
                self.states[state.STATE_COMBAT] = state.S_COMBAT_ON
                self.combatStartTick = time.time()
                # attackerId has a valid entity ID if we have been attacked 
                # as opposed to having started hostilities ourselves
                if attackerId != None:
                        self.setTarget(attackerId)   # automatically target the attacker

                # send an UNDER_ATTACK event to notify the attacker that he now has aggro from us
                target = self.getTargetEntity()
                target.rpcProcessEvent(self.id, event.UNDER_ATTACK, event.ATTACK_EVENT_AGGRO)
                        
                # add the target to our aggro-on list (we have aggro on this entity)
                self.aggroOn(self.targetId)
                
                # HACK: start using the development test default weapon is slot 0
                self.combatResolver.startSlot(0)
                
                # at this point we start to AutoAttack: set state accordingly!
                self.states[state.STATE_ATTACK] = state.S_ATTACK_ON
                 
                 
        # exiting combat mode also stops autoattack
        def exitCombat(self):
                ''' exit combat will restate an Actor's combat state to off, remove a current target from the aggroOn list,
                        relay a AGGRO_DROPPED event to the target, cancel the target and finally stop autoattack mode '''
                        
                print "Actor_%d.exitCombat()" % (self.id)
                self.states[state.STATE_COMBAT] = state.S_COMBAT_OFF
                if self.targetId:
                        self.deAggroOn(self.targetId)
                        target = self.getTargetEntity()
                        target.rpcProcessEvent(self.id, event.AGGRO_DROPPED, 0 )

                self.targetId = None
                if self.states[state.STATE_ATTACK] == state.S_ATTACK_ON:
                        self.stopAutoattack()

        # stop autoattack does NOT exit combat mode
        def stopAutoattack(self):
                print "Actor_%d.stopAutoattack()" % (self.id)
                self.combatResolver.stopSlot(0)
                self.states[state.STATE_ATTACK] = state.S_ATTACK_OFF
                self.allClients.rpcChangeState(state.STATE_ATTACK, state.S_ATTACK_OFF)

        def pauseAutoattack(self, restart=False):
                ''' pauseAutoattack does not turn the auto attack state off but it stops the combat resolver from
                    processing weapon swings. This is used when our target is temporarily out off range '''
                print "Actor_%d.pauseAutoattack() %s" % (self.id, restart)
                if not restart:
                        self.combatResolver.stopSlot(0)
                        self.states[state.STATE_ATTACK] = state.S_ATTACK_PAUSED
                else:
                        self.combatResolver.startSlot(0)
                        self.states[state.STATE_ATTACK] = state.S_ATTACK_ON
                
        def setTarget(self, entityId):
                ''' aquire the entity identified by entityId as new target. This also triggers a combatResolver attacktable rebuild '''
                self.targetId = entityId
                self.combatResolver.setTargetId(entityId)

        def targetLost(self): 
                '''     a targetLost condition this will usually occur if our target leaves the world (dies or logs off) 
                    we do automaticall deAggroOn the former target (remove it from the aggroOn list) and stop auto attacking '''
                print "Actor_%d.targetLost()" % (self.id)
                self.deAggroOn(self.targetId)
                self.stopAutoattack()
                self.targetId = None

        # sourceId is the Id of the entity that has dealt the killing blow 
        def die(self, sourceId):                
                ''' the purpose of this function should be kind of obvious :) '''
                self.states[state.STATE_STANCE] = state.S_STANCE_DEAD
                self.states[state.STATE_COMBAT] = state.S_COMBAT_OFF
                self.states[state.STATE_ATTACK] = state.S_ATTACK_OFF

                # tell everyone we had aggro on that we just de-aggroed (duh, we're dead stupid)
                for entityId in self.aggroOnList:
                        try:
                                entity = BigWorld.entities[entityId]
                                entity.rpcProcessEvent(self.id, event.AGGRO_DROPPED, 0 )
                        except:
                                pass
                        
                # send our death location to base (it doesnt have this information)
                # so that it can register us with the Morgue 
                self.base.rpcDeathLoc(self.position, self.direction, self.modelNumber)    
                
                #self.destroy()
                self.addTimer(0.5, 0, 1)  # userdata=1 tells timer proc what to do: destroy() this object

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

        # someone hit us! 
        # damage is the amount (if any), sourceId is the entity ID of the attacker
        def rpcReceiveDamage(self, damage, sourceId):
                self.timeLastHitReceived = time.time()
                # if not self.states[state.STATE_COMBAT] == state.S_COMBAT_ON:
                        # self.enterCombat(sourceId)
                hp = self.characterStats.HP
                newValue = hp.curValue - damage
                hp.curValue = newValue
                self.updateHealthPercent()
                if hp.curValue <= 0:
                        # we're dead: destroy cell component
                        # this will trigger the onDestroy() callback and OnLoseCell() on our base
                        # first inform clients though   
                        self.die(sourceId)
        
        def _getRpcFunc(self, funcCode):
                try:
                        func = self.eventProc[funcCode] 
                        return func
                except:
                        return None

        # RPC Event with INT32 data parameter
        def rpcProcessEvent(self, sourceId, eventType, eventValue):
                print "Actor_%d.rpcProcessEvent(): sourceId=%d, eventType=%s, eventValue=%d" % \
                  (self.id, sourceId, event.EVENTS[eventType], eventValue)
                # call the event processor for this event (if any)
                # print len(self.eventProc)
                func = self._getRpcFunc(eventType)
                if func != None: func(sourceId, eventValue)
                else: print 'Actor_%d RPC event function for %s not found' % (self.id, event.EVENTS[eventType])
                        
        # RPC Event with STRING data parameter
        def rpcProcessStringEvent(self, sourceId, eventType, eventString):
                print "Actor_%d.rpcProcessStringEvent(): sourceId=%d, eventType=%s, eventString=%s" % \
                  (self.id, sourceId, event.EVENTS[eventType], eventString)
                # call the event processor for this event (if any)
                # print len(self.eventProc)
                func = self._getRpcFunc(eventType)
                if func != None: func(sourceId, eventString)
                else: print 'Actor_%d RPC event function for %s not found' % (self.id, event.EVENTS[eventType])