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

Go to the documentation of this file.

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

import BigWorld
import random
import time

import Avatar
from Actor import Actor

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

from Resources import ResourceDB as RDB

class Mob(BigWorld.Entity, Actor):

        def __init__(self):
                BigWorld.Entity.__init__(self)
                Actor.__init__(self)
                self.combatStartTick = None
                
                # equip weapon from spawn definition (if any)
                spawnDef = RDB.spawns[self.spawnDefId]
                weaponId = spawnDef.weaponId
                if weaponId != None:
                        print "Mob_%d equiping weapon, weapondef=%s" % (self.id, weaponId)
                        weapon = RDB.items[weaponId]
                        self.combatResolver.equipWeapon(weapon, 0)   # for now just one default weapon slot for mobs
                        
                # our event processing plugins
                self.addEventProc(event.UNDER_ATTACK, self.eventUnderAttack)


        # -------------------------------------------------------------------------
        # Section: Callbacks
        # -------------------------------------------------------------------------
                
        # callback for the Timer started in Actor.__init__
        def onTimer(self, timerId, userData):
                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()
                                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() 
                                                        # at this point we should start to chase the opponent once our mobs can move!
                                        elif self.states[state.STATE_ATTACK] == state.S_ATTACK_PAUSED:
                                                self.pauseAutoattack(restart=True) 
                                                
                                        # this is different for Mobs: we cancel combat (and de-aggro) once the entity
                                        # we hold aggro on has managed to get far way enough from us or dies
                                        inAggroHoldRange = consts.DROP_AGGRO_DISTANCE - dist > 0.0   # aggro drop distance should go into spawnDef
                                        if not inAggroHoldRange:
                                                print 'Mob_%d: distance to target=%.3f, out off aggro hold range; canceling combat mode' % (self.id, dist)
                                                # MFU: this will not be correct if we are being attacked by more than one opponent at once!
                                                self.exitCombat()
                        else:
                                # no target currently
                                # if we are still in combat but do not hold aggro ON anyone anymore we can cancel combat mode
                                if not self.haveAggroOn():
                                        self.exitCombat()
                                
                else:
                        #       - health & power regen
                        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: Actor extentions/overrides
        # -------------------------------------------------------------------------
        def die(self, sourceId):
                xp = 0
                if not self.isPlayer:
                        xp = RDB.spawns[self.spawnDefId].Xp
                try:
                        killer = BigWorld.entities[sourceId]
                except:
                        print "Mob_%d.die(): ERROR no entity found for my killer:%d" % (self.id, sourceId)
                finally:
                        killer.base.rpcProcessEvent(self.id, event.ENTITY_KILL, xp)

                Actor.die(self, sourceId)


        # -------------------------------------------------------------------------
        # Section: Game Event Processing
        # -------------------------------------------------------------------------
        
                
        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 "Mob_%d.eventUnderAttack(): attackerId=%d, eventValue=[%d]%s" \
                      % (self.id, attackerId, eventValue, event.ATTACK_EVENTS[eventValue])

                self.aggroFromEntity(attackerId)  # add to aggro-from list
                self.aggroOn(attackerId)          # add to aggro-on list
                
                if not self.states[state.STATE_COMBAT] == state.S_COMBAT_ON:
                        self.enterCombat(attackerId)
                        # the mob should turn towards an attacker automatically
                        # changes to our heading get relayed to clients automatically
                        target = self.getTargetEntity()
                        self.facePosition(target.position)