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

Go to the documentation of this file.

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


# This is the client personality script.  
# Think of it as the bootstrap script for the client.  It contains functions that are called
# on initialisation, shutdown, and handlers for various input events.

import GUI as SYSGUI

import BigWorld
from Keys import *
from bwdebug import *


from config.consts import SYSTEM_VERSION
from config.state import *

from Resources import ResourceDB as RDB
__import__('__main__').RDB = RDB

from Helpers import PyGUI
__import__('__main__').PyGUI = PyGUI

import AnGUI
__import__('__main__').AnGUI = AnGUI

import AvatarModel
__import__('__main__').AMM = AvatarModel.AvatarModelManager

import ItemManager
__import__('__main__').ITM = ItemManager.ItemManager

import ConnectionManager

def _fadeOut():
        global loadingScreen
        loadingScreen.colour.alpha = loadingScreen.colour.alpha - 2
        if loadingScreen.colour.alpha > 0:
                BigWorld.callback(.1, _fadeOut)
        else:
                SYSGUI.delRoot(loadingScreen)
                loadingScreen=None
                
# ------------------------------------------------------------------------------
# Section: Required BigWorld Engine callbacks
# ------------------------------------------------------------------------------

# The init function is called as part of the BigWorld initialisation process.
# It receives the BigWorld xml config files as arguments.  This is the best
# place to configure all the application-specific BigWorld components, like
# initial camera view, etc...
def init( scriptsConfig, engineConfig, prefs ):
        
        print "------------------------------------------------"
        print "INIT ANORIA CLIENT %s" % (SYSTEM_VERSION)
        print "------------------------------------------------"

        # load static data
        RDB.load(isServer=False)

        global loadingScreen
        loadingScreen = SYSGUI.Simple("gui/maps/anoria-logo-01.tga")
        loadingScreen.width = 2.0
        loadingScreen.height = 2.0
        loadingScreen.position.y = 0.5
        
        SYSGUI.addRoot(loadingScreen)

        # ans.scriptsConfig = scriptsConfig
        # ans.engineConfig = engineConfig
        # ans.preferences = prefs
        
        # GUI
        AnGUI.service.setupGUI()

        if scriptsConfig.readBool( "server/online" ):
                ConnectionManager.service.doConnect(scriptsConfig.readString( "server/host" ))
        else:
                _initOffline( scriptsConfig )

        # install standard hotkeys
        AnGUI.service.addHotkey(KEY_Q, 'AutoAttackToggle')
        AnGUI.service.addHotkey(KEY_P, 'ProficienciesWindowToggle')
        
        # CursorCamera (cc) setup
        cc = BigWorld.CursorCamera()
        cc.source = BigWorld.dcursor().matrix
        cc.target = BigWorld.PlayerMatrix()
        BigWorld.dcursor().yawReference = cc.invViewMatrix
        BigWorld.dcursor().minYaw = -2
        BigWorld.dcursor().maxYaw =  2

        cc.pivotPosition = scriptsConfig.readVector3('camera/defTargetOffset', (0.0, 1.8, 0.0))
        cc.pivotMaxDist =  scriptsConfig.readFloat('camera/maxDistanceFromPivot', cc.pivotMaxDist)
        cc.pivotMinDist = scriptsConfig.readFloat('camera/minDistanceFromPivot', cc.pivotMinDist)
        cc.terrainMinDist = scriptsConfig.readFloat('camera/minDistanceFromTerrain', cc.terrainMinDist)
        cc.maxVelocity = scriptsConfig.readFloat('camera/maxVelocity', cc.maxVelocity)
        cc.movementHalfLife = scriptsConfig.readFloat('camera/movementHalfLife', cc.movementHalfLife)
        cc.turningHalfLife = scriptsConfig.readFloat('camera/turningHalfLife', cc.turningHalfLife)
        BigWorld.camera(cc)
        
        # initial cursor set up
        AnGUI.Cursor.showCursor(True)   
        
        # and we're done
        print 'Anoria client personality init() done.'

        

# This is called immediately after init() finishes.
def start():
        # start fading out our little temp title overlay 
        BigWorld.callback(.1, _fadeOut)


# This method is called just before the game shuts down.
def fini():
        BigWorld.savePreferences()


# This is called by BigWorld when player moves from inside to outside
# environment, or vice versa.  It should be used to adapt any personality
# related data (eg, camera position/nature, etc).
def onChangeEnvironments( inside ):
        pass
        
# This is called by the engine when a system generated message occurs.
def addChatMsg( msg ):
        global ans
        ans.console.addMsg(msg)

# Keyboard event handler
# Note that BigWorld also treats mouse clicks as "key events"
def handleKeyEvent( down, key, mods ):
        # print 'Anoria.handleKeyEvent() key=%d' % (key)
        
        # handle special cases: quit via alt-f4 and alt-tab full screen changing
        if down and key == KEY_F4 and mods == MODIFIER_ALT:
                if BigWorld.player() != None:
                        try:
                                BigWorld.player().base.logOff()
                        except: pass
                        BigWorld.quit()
                        return True
        elif down and key == KEY_RETURN and mods == MODIFIER_ALT:
                BigWorld.changeVideoMode( BigWorld.videoModeIndex(), not BigWorld.isVideoWindowed() )
                return True

        handled = AnGUI.service.handleKeyEvent(down, key, mods)
        
        # try the camera
        # print 'handled='+str(handled)
        cam = BigWorld.camera()
        if cam is not None and handled is False:
                handled = cam.handleKeyEvent((down, key, mods))
        
        return handled

        
   
# Keyboard char event handler
# called whenever a character has been entered by the user, the GUI needs these
# for consoles/text edit controls etc.
def handleCharEvent( char, key, mods ):
        return SYSGUI.handleCharEvent( char, key, mods )

# Mouse movement event handler
def handleMouseEvent( dx, dy, dz ):
        # try the gui
        PyGUI.handleMouseEvent(dx, dy, dz)
        handled = SYSGUI.handleMouseEvent(dx, dy, dz)
        return handled

# Joystick event handler: we dont do anything with these yet
def handleAxisEvent( axis, value, dTime ):
        return False


# ------------------------------------------------------------------------------
# Section: private Helper methods
# ------------------------------------------------------------------------------

def _initOffline( scriptsConfig ):

        print "beginning offline startup ..."

        # Create a space for the client to inhabit
        spaceID = BigWorld.createSpace()

        # Load the space that is named in scripts_config.xml
        BigWorld.addSpaceGeometryMapping(
                spaceID, None, scriptsConfig.readString( "space" ) )

        # Create the player entity, using positions from scripts_config.xml
        playerID = BigWorld.createEntity(
                scriptsConfig.readString( "player/entityType" ),
                spaceID, 0,
                scriptsConfig.readVector3( "player/startPosition" ),
                scriptsConfig.readVector3( "player/startDirection" ),
                {} )

        BigWorld.player( BigWorld.entities[ playerID ] )