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

Go to the documentation of this file.

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

import BigWorld
import math

import Anoria
import AnGUI

import Stats

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

class Actor(Stats.StatsManager):

        def __init__(self):
                Stats.StatsManager.__init__(self, isServer=False)
                self.isPlayer = False
                self.target = None
                self.matchCaps = None
                self.matchCapsBak = None

                self.states=[S_STANCE_IDLE, S_MOVE_NONE, S_COMBAT_OFF, S_ATTACK_OFF]
                self.stateChangeHandlers = ( \
                                        self.stanceStateChange,
                                        self.moveStateChange,
                                        self.combatStateChange,
                                        self.attackStateChange
                                        )
                
                # our event processing plugins
                self.eventProc = {}
                self.eventProc[event.YOU_DIED] = self.eventYouDied 

                # Note that the following already exist: 
                #       - self.characterStats
                #       - self.characterSkills 
                #       - self.healthPercentage
                # BigWorld creates them automatically due to their declaration in the Actor entity definition file 



        def setTarget(self, entity):
                self.target = entity
                

        # -------------------------------------------------------------------------
        # Section: ANIMATION CONTROL
        # -------------------------------------------------------------------------

        def buildActionTable(self):
                self.actionTable = {
                        ACTION_IDLE:     self.model.Idle, 
                        ACTION_RECOIL:   self.model.Recoil, 
                        ACTION_DIE:      self.model.Die, 
                }

        # default action matcher setup
        # call only after we already have a model!
        def setupActionMatcher(self):
                self.am = BigWorld.ActionMatcher( self )
                self.am.turnModelToEntity = True
                self.am.matcherCoupled = 1        # switch the matcher "on"
                self.am.matchCaps = [MATCH_CAP_ON_LAND,]
                self.am.entityCollision = 1
                self.am.collisionRooted = 0
                self.am.footTwistSpeed = math.radians(270)
                
                
                # replace the model's default motor with our own ActionMatcher
                if self.am.owner != None: self.am.owner.delMotor( self.am )
                self.model.motors = ( self.am, )

        def pushMatchCaps(self):
                self.matchCapsBak = self.matchCaps[:]     # use a slice: actually copy the list, not just a ref to it

        def popMatchCaps(self):
                if self.matchCapsBak != None:
                        self.matchCaps = self.matchCapsBak[:]
                        self.am.matchCaps = self.matchCaps
                        self.matchCapsBak = None
        
        def addMatchCap(self, cap):
                # print "Avatar.addMatchCap()"
                self.matchCaps.append(cap)
                self.am.matchCaps = self.matchCaps

        def delMatchCap(self, cap):
                # print "Avatar.delMatchCap()"
                try:
                        self.matchCaps.remove(cap)
                except:
                        return
                self.am.matchCaps = self.matchCaps
                
        def hasMatchCap(self, cap):
                if cap in self.matchCaps: return True
                return False

        # -------------------------------------------------------------------------
        # Section: state change handlers
        # -------------------------------------------------------------------------
        
        def stanceStateChange(self, newState):
                print "Actor.stanceStateChange() newState=%d" % (newState)
                self.states[STATE_STANCE] = newState

        def moveStateChange(self, newState):
                print "Actor.moveStateChange() newState=%d" % (newState)
                self.states[STATE_MOVE] = newState

        def combatStateChange(self, newState):
                print "Actor.combatStateChange() newState=%d" % (newState)
                self.states[STATE_COMBAT] = newState

        def attackStateChange(self, newState):
                print "Actor.attackStateChange() newState=%d" % (newState)
                self.states[STATE_ATTACK] = newState
        
        # -------------------------------------------------------------------------
        # Section: RPC
        # -------------------------------------------------------------------------

        # this needs to be named set_<propertyName> because its implicitly declared like that
        # by BigWorld for ALL_CLIENTS properties like healthPercentage 
        def set_healthPercent(self, old_hp):
                # print "Mob.set_healthPercent(): hp=%f, old_hp=%f" % (self.healthPercent, old_hp)
                # Anoria.ans.angui.updateTargetHealth(self, instantly=True)
                if AnGUI.service.targetHud.focusEntity == self or BigWorld.target() == self:
                        AnGUI.service.targetHud.updateTargetHealth(self, instantly=True)
                if self.isPlayer:
                        AnGUI.service.avatarHud.setHpBar(self.healthPercent / 100.0)

        def rpcPerformAction(self, actionId):
                print "Actor.rpcPerformAction() actionId=%d" % (actionId)
                action = self.actionTable[actionId]
                action()

        # set a state to the given value
        def rpcChangeState(self, stateIndex, stateValue):
                func = self.stateChangeHandlers[stateIndex]
                func(stateValue)
        
        # something is happening to us: the event will tell us what and whodunnit
        def rpcProcessEvent(self, sourceId, eventType, eventValue):
                print "[%d].Actor.rpcProcessEvent(): sourceId=%d, eventType=%d [%s], eventValue=%d" % \
                  (self.id, sourceId, eventType, event.EVENTS[eventType], eventValue)
                # call the event processor for this event (if any)
                # print len(self.eventProc)
                func = None
                try:
                        func = self.eventProc[eventType]        
                except:
                        pass

                if func != None: func(sourceId, eventType, eventValue)
                else: print 'rpc event function code=%d not found' % (eventType)
                
        # -------------------------------------------------------------------------
        # Section: Event Processing
        # -------------------------------------------------------------------------

        def addEventProc(self, eventId, proc):
                # print "adding event:%d" % (eventId)
                self.eventProc[eventId]=proc
                
        def eventYouDied(self, attackerId, eventyType, eventValue):
                print "[%d].eventYouDied(): attackerId=%d, eventValue=%d" % (self.id, attackerId, eventValue)
                # next = self.model.Dead
                # self.model.Die(0, next, 1)