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

Go to the documentation of this file.

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


import BigWorld
import GUI as SYSGUI
import Keys
import math

from Resources import ResourceDB as RDB
from AvatarModel import AvatarModelManager as AMM

import Anoria
import AnGUI
from Actor import Actor
from Helpers import TargetCaps

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

class Avatar(BigWorld.Entity, Actor):

        def __init__(self):
                BigWorld.Entity.__init__(self)
                Actor.__init__(self)
                self.am = None
                self.targetCaps = [TargetCaps.CAP_CAN_HIT]
                self.hasMouseOverTarget = None
                
        def enterWorld( self ):

                # Set the position/movement filter to correspond to an avatar
                self.filter = BigWorld.AvatarFilter()

                # model - test code - this is hacky atm, dont really know what I am doing here ...
                # self.model = BigWorld.Model( "characters/bipedgirl.model" )
                nm = AMM.makeModel( self.modelNumber, self.model )
                self.model = nm
                
                # add a sword 
                sword = BigWorld.Model("global/items/weapons/sword_bastard.model")
                self.model.right_hand = sword
                
                # add a shadow entity giving our avatar a nice shadow
                BigWorld.addShadowEntity(self)

                # action matcher setup
                self.setupActionMatcher()

                # matchCaps default setup for the private matchCaps list (matching the BigWorld one above)
                self.matchCaps = [MATCH_CAP_ON_LAND,]
                
                # unsure about this one - FD uses it - commented out for now
                # self.entityDirProvider = BigWorld.EntityDirProvider(self, 1, 0)
                
                                
        # -------------------------------------------------------------------------
        # Section: UTILITIES
        # -------------------------------------------------------------------------

        # This method faces towards a position.
        def facePosition(self, pos):
                print "Avatar.facePosition() not implemented yet!"
                
        # adapt system text messages (combat, quest dialogue etc) to 1'st or 3'rd person
        def doTextSubst(self, text, val1=0):
                                                
                if text.find('$SELF') != -1:
                        name=self.name
                        if self.isPlayer: name = RDB.strings[1000]
                        text = text.replace('$SELF', name)
                if text.find('$POS') != -1:
                        pos = RDB.strings[1001]
                        if not self.isPlayer: 
                                if self.gender == GENDER_MALE:
                                    pos = RDB.strings[1002]
                                if self.gender == GENDER_FEMALE:
                                    pos = RDB.strings[1003]
                                if self.gender == GENDER_NEUTRAL:
                                    pos = RDB.strings[1004]
                        text = text.replace('$POS', pos)
                if text.find('$3RA'):
                        if not self.isPlayer:
                                text = text.replace('$3RA', RDB.strings[1104])
                        else:
                                text = text.replace('$3RA', '')
                if text.find('$3RB'):
                        if not self.isPlayer:
                                text = text.replace('$3RB', RDB.strings[1105])
                        else:
                                text = text.replace('$3RB', '')
                if text.find('$1'):
                        text = text.replace('$1', str(val1))
                        
                return text

                
                

        # -------------------------------------------------------------------------
        # Section: state change handlers super class overrides
        # -------------------------------------------------------------------------

        def attackStateChange(self, newState):
                self.states[STATE_ATTACK] = newState
                if newState == S_ATTACK_ON:
                        if self.isPlayer:
                                text=self.doTextSubst(RDB.strings[1], None)
                                AnGUI.service.console.script.addMsg(text, 1l)
                                self.facePosition(self.target.position)

                        self.addMatchCap(MATCH_CAP_MELEE_1)
                else:
                        if self.isPlayer:
                                text=self.doTextSubst(RDB.strings[2], None)
                                AnGUI.service.console.script.addMsg(text, 1l)
                        
                        self.delMatchCap(MATCH_CAP_MELEE_1)
        
        # -------------------------------------------------------------------------
        # Section: RPC
        # -------------------------------------------------------------------------
        

        def rpc_chatText(self, text, channel):
                # print 'Avatar.rpc_chatText(): channel=%d, text=%s' % (channel, text)
                AnGUI.service.console.script.addMsg(text, channel)

        def rpc_printString(self, stringId, channel):
                " displays a system string in the output area designated by the channel parameter "
                text = RDB.strings[stringId]
                AnGUI.service.console.script.addMsg(text, channel)

        # TODO: change this into an event
        def rpcTargetLost(self):
                self.rpc_printString(11, MELEE_COMBAT_CHANNEL_ID)
                self.setTarget(None)
                                                
        # called by the cell combat code for every single meleeAttack an avatar performs
        def rpcMeleeAttack(self, entityId, hitType, damage):

                # this is sort of a hack: turn on the melee combat stance for the benefit
                # of clients that came near us only after we had turned auto attack "on" initially
                if not self.hasMatchCap(MATCH_CAP_MELEE_1):
                        self.addMatchCap(MATCH_CAP_MELEE_1)

                # play attack animation: for now we play always the same single animation
                self.model.CCActFwdHit()  
                try:
                        entity=BigWorld.entities[entityId]
                        BigWorld.callback(0.3, entity.model.Recoil)
                except:
                        print "Avatar.rpcMeleeAttack(): cant find entity for passed in target entityId=%d" % (entityId)
                        
                text2 = None
                if hitType == HIT_TYPE_MISS:
                        text = RDB.strings[6]
                elif hitType == HIT_TYPE_EVADE:
                        text = RDB.strings[7]
                elif hitType == HIT_TYPE_CRIT:
                        text = RDB.strings[8]
                        text2= RDB.strings[5]
                elif hitType == HIT_TYPE_CRUSH:
                        text = RDB.strings[9]
                        text2= RDB.strings[5]
                elif hitType == HIT_TYPE_NORMAL:
                        text = RDB.strings[5]

                text = self.doTextSubst(text, val1=damage)
                self.rpc_chatText(text, MELEE_COMBAT_CHANNEL_ID)
                if text2 != None:
                        text2 = self.doTextSubst(text2, val1=damage)
                        self.rpc_chatText(text2, MELEE_COMBAT_CHANNEL_ID)
                        

# -------------------------------------------------------------------------
# PLAYER AVATAR
# -------------------------------------------------------------------------

class PlayerAvatar(Avatar):

        # I actually dont think this gets EVER called ?????? Not entirely sure but better put all setup code
        # into onEnterWorld()
        def __init__(self):
                Avatar.__init__(self)
                print "PlayerAvatar.__init__()"
                
        # -------------------------------------------------------------------------
        # Section: Anoria Game Event Processing
        # -------------------------------------------------------------------------
        
        # eventValue is our current percentage of xp towards the next proficiencies point
        def eventEntityKill(self, entityId, eventType, eventValue):
                xp = float(eventValue)/100.0
                self.rpc_printString(12, 0)
                AnGUI.service.proficienciesWindow.setXpBar(xp)
                
        def eventProficiencyPointGain(self, entityId, eventType, eventValue):
                self.rpc_printString(13, 0)
                self.unspentProficiencyPoints += 1
                self.totalProficiencyPoints += 1
                AnGUI.service.proficienciesWindow.setPoints(self.unspentProficiencyPoints, self.totalProficiencyPoints)
        
        def eventStatUpdate(self, entityId, eventType, eventValue):
                stat = None
                if eventType == event.STAT_UPDATE_CON:
                        stat = self.characterStats.CON
                        name = 'CON'
                elif eventType == event.STAT_UPDATE_STR:
                        stat = self.characterStats.STR
                        name = 'STR'
                elif eventType == event.STAT_UPDATE_DEX:
                        stat = self.characterStats.DEX
                        name = 'DEX'
                elif eventType == event.STAT_UPDATE_INT:
                        stat = self.characterStats.INT
                        name = 'INT'
                        
                if stat != None:
                        stat.curValue=eventValue
                        AnGUI.service.avatarHud.setStat(name, eventValue)
                        # print 'stat update ', eventValue
                
        # -------------------------------------------------------------------------
        # Section: system call backs
        # -------------------------------------------------------------------------

        def onLeaveWorld(self):
                print "PlayerAvatar.onLeaveWorld()"
                BigWorld.cancelCallback(self.callbackId)
                AnGUI.service.cancelListener(self)
                
        def onEnterWorld( self, prereqs, initial=1 ):

                if initial:
                        Avatar.enterWorld(self)

                # can set the Actor.StatsManager up now that we're "in world" and have the server data
                self.initStatsData()
                
                self.in_mouse_move = False;
                self.isPlayer = True

                # install the game event handlers
                Actor.addEventProc(self, event.ENTITY_KILL, self.eventEntityKill)
                Actor.addEventProc(self, event.PROFICIENCY_POINT_GAIN, self.eventProficiencyPointGain)
                Actor.addEventProc(self, event.STAT_UPDATE_CON, self.eventStatUpdate)
                Actor.addEventProc(self, event.STAT_UPDATE_STR, self.eventStatUpdate)
                Actor.addEventProc(self, event.STAT_UPDATE_DEX, self.eventStatUpdate)
                Actor.addEventProc(self, event.STAT_UPDATE_INT, self.eventStatUpdate)
                
                # test weather system manipulation
                weather = BigWorld.weather(self.spaceID)
                weatherSystem = weather.system("CLOUD")
                weatherSystem.direct(1, (0.8, 0.5, 0 , 0), 1)
                weather.windAverage(0.45, 0.7)
                weather.windGustiness(0.9)
                
                # Set the position/movement filter to correspond to a player avatar
                self.filter = BigWorld.PlayerAvatarFilter()

                # Setup the physics for the Avatar
                self.physics = BigWorld.STANDARD_PHYSICS
                self.physics.velocity           = ( 0.0, 0.0, 0.0 )
                self.physics.velocityMouse      = "Direction"
                self.physics.angular            = 0             
                self.physics.collide = 1
                self.physics.fall = 1
                self.physics.modelWidth = 0.47
                self.physics.modelDepth = 0.3

                # not sure about this one - FD does it though
                self.am.velocityProvider = self.physics.uncorrectedVelocity

                # Targetting stuff
                # BigWorld.target.exclude = self
                self.enableMouseTargetting()
                BigWorld.target.caps(TargetCaps.CAP_CAN_HIT)
                self.minAimScore = 0.0
                self.maxAimScore = 0.99
                self.enableMouseTargetting()
                
                # load the developer helper window
                self.devwin=SYSGUI.load("gui/devwin.gui")
                self.devwin.script.active(True)
                
                # install the update callback for the devwin hud window
                self.callbackId = BigWorld.callback(1.0, self.updateCallback) 
                        
                # subscribe to GUI events we care about
                AnGUI.service.addListener(self, AnGUI.GuiEvent("AutoAttackToggle"))
                
                # update the proficiencies window with our current points standings
                AnGUI.service.proficienciesWindow.setPoints(self.unspentProficiencyPoints, self.totalProficiencyPoints, self.proficienciesList)
                
                # update the avatarHud
                AnGUI.service.avatarHud.setStats(str=self.getStat('STR'), con=self.getStat('CON'), 
                                                                                 dex=self.getStat('DEX'), int=self.getStat('INT')) 
                AnGUI.service.avatarHud.setHpBar(self.healthPercent / 100.0)

        def _sign(self, num):
                if num > 0.0:
                        return 1
                elif num == 0.0:
                      return 0 
                else:
                        return -1
                 
                 
        def handleKeyEvent( self, isDown, key, mods ):

                # print 'PlayerAvatar.handleKeyEvent() key=%d' % (key)

                if key==Keys.KEY_RIGHTMOUSE:
                        self.handleRightMouseButton(isDown)
                elif key==Keys.KEY_LEFTMOUSE:
                        self.handleLeftMouseButton(isDown)
                elif key==Keys.KEY_ESCAPE:
                        self.handleEscapeKey(isDown)
                                        
                # Get the current velocity
                v = self.physics.velocity

                # Update the velocity depending on the key input: implements a simple WSAD scheme
                if key in (Keys.KEY_W,Keys.KEY_S,Keys.KEY_A,Keys.KEY_D):
                        if isDown:
                                self.pushMatchCaps()
                                self.delMatchCap(9)
                        else:
                                self.popMatchCaps()

                
                speed = 5.0
                if key == Keys.KEY_W:
                        v.z = isDown * speed
                elif key == Keys.KEY_S:
                        v.z = isDown * -speed
                elif key == Keys.KEY_A:
                        v.x = isDown * -speed
                elif key == Keys.KEY_D:
                        v.x = isDown * speed

                if v.x != 0.0 and v.z != 0.0:     # moving diagonally
                        v.x = self._sign(v.x)*speed*0.707
                        v.z = self._sign(v.z)*speed*0.707
                        
                # Save back the new velocity
                self.physics.velocity = v

        # update contents of our development helper HUD
        #called 10 times/sec: dont waste _any_ time here
        def updateCallback(self):
                self.callbackId = BigWorld.callback(0.1, self.updateCallback) # re-submit, call 10 times/sec
                p=self.position
                self.devwin.line1.text="%.2f,%.2f,%.2f,%.2f" % (p.x, p.y, p.z,self.yaw)
                try:
                        self.devwin.line2.text= "fps: %.2f" % (float(BigWorld.getWatcher("Render/FPSAverage")))
                except:
                        pass
                
                # update target hud: this enables the "mouse over" target hud display
                e=BigWorld.target()
                if e != None:
                        self.hasMouseOverTarget = True
                        AnGUI.service.targetHud.gui.script.active(True)
                        AnGUI.service.targetHud.targetFocus(e)
                elif self.hasMouseOverTarget:
                        self.hasMouseOverTarget = False
                        # switch hud off unless the avatar currently has an object permanently targetted 
                        if  self.target==None:                  
                                AnGUI.service.targetHud.gui.script.active(False)
                        else:
                                AnGUI.service.targetHud.targetFocus(self.target)
                
                

        def handleConsoleInput(self, line):
                AnGUI.service.console.script.addMsg("You say: %s" % (line), 1l)
                self.cell.rpcSay(line)

        # Handle AnGUI events 
        def handleGuiEvent(self, event):
                eventName = event.name
                eventAction = event.action
                # print "Avatar.handleGuiEvent(): name=%s action=%s" % (eventName, eventAction)
                if eventName == "AutoAttackToggle":
                        self.cell.rpcAutoAttackToggle()
                        
                
        
        # -------------------------------------------------------------------------
        # Section: utility
        # -------------------------------------------------------------------------
        
        # This method faces us towards a position.
        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.physics.turn = yaw-self.yaw
                BigWorld.dcursor().yaw=yaw    # rotate the direction cursor (and with it the camera) too
        
        def enableMouseTargetting( self ):
                if not hasattr( self, "mouseTargettingMatrix" ):
                        self.mouseTargettingMatrix = BigWorld.MouseTargettingMatrix()
                BigWorld.target.source = self.mouseTargettingMatrix
                BigWorld.target.selectionFovDegrees = 2.0
                BigWorld.target.deselectionFovDegrees = 5.0


        def disableMouseTargetting( self ):
                if not hasattr( self, "playerTargettingMatrix" ):
                        self.playerTargettingMatrix = BigWorld.ThirdPersonTargettingMatrix( BigWorld.PlayerMatrix() )
                BigWorld.target.source = self.playerTargettingMatrix
                BigWorld.target.selectionFovDegrees = 15.0
                BigWorld.target.deselectionFovDegrees = 20.0

        # -------------------------------------------------------------------------
        # Section: world interaction
        # -------------------------------------------------------------------------

        def setTarget(self, entity):
                if entity != None:
                        self.target = entity
                        self.devwin.line3.text='target: %s' % (entity.name)
                        # communicate the new target to server: transmit the id
                        self.cell.rpc_setTarget(entity.id)
                else:
                        self.target = None
                        self.devwin.line3.text='target:'
                        self.cell.rpc_setTarget(0)
                
        # -------------------------------------------------------------------------
        # Section: mouse click handling
        # -------------------------------------------------------------------------

        def handleLeftMouseButton(self, isDown):
                ''' left mouse button click handler
                        store the entity that BigWorld.target() returns (if any) a current target
                '''     
                if isDown:
                        e=BigWorld.target()
                        if e != None:
                                self.setTarget(e)

        def handleRightMouseButton(self, isDown):
                ''' Note that showCursor() below actually does a lot more than just switching the
                    cursor display on/off! When the GUI cursor is "switched" off the BigWorld cursor
                        is set to to the DC (direction cursor) and this actually couples mouse movement 
                        onto your entity/avatar model (see the init() set up in Anoria.py '''
                        
                if isDown and not self.in_mouse_move:
                        self.in_mouse_move = True
                        self.physics.userDirected = 1
                        AnGUI.Cursor.showCursor(False)
                if not isDown and self.in_mouse_move:
                        self.in_mouse_move = False
                        self.physics.userDirected = 0
                        AnGUI.Cursor.showCursor(True)

        # -------------------------------------------------------------------------
        # Section: hot key handlers
        # -------------------------------------------------------------------------
        def handleEscapeKey(self, isDown):
                if isDown and self.target != None:
                        self.setTarget(None)