CircleDeflection

'''
(c) Dellux 2013
'''
import BigWorld
import GUI
import Keys
import weakref
import math
import Math
import CommandMapping
import AvatarInputHandler.control_modes as AvatarInputHandler
from Avatar import PlayerAvatar
from gui.Scaleform.Battle import Battle
from gui.Scaleform.Battle import _TimeInterval
from gui.Scaleform.Flash import Flash
from gui import DEPTH_OF_Aim

class CircleDeflection(Flash):
    UPDATE_INTERVAL = 0.03

    def __init__(self, parentUI):
        Flash.__init__(self, 'CircleDeflection.swf')
        self._CircleDeflection__timeInterval = None
        self._CircleDeflection__isVisible = None
        self.component.wg_inputKeyMode = 1
        self.component.position.z = DEPTH_OF_Aim
        self.movie.backgroundAlpha = 0
        self.component.focus = False
        self.component.moveFocus = False
        self.component.heightMode = 'PIXEL'
        self.component.widthMode = 'PIXEL'
        self.flashSize = GUI.screenResolution()


    def start(self):
        global isCDVisible, isTracerVisible
        self.active(True)
        self.setup()
        self._CircleDeflection__timeInterval = _TimeInterval(self.UPDATE_INTERVAL, 'update', weakref.proxy(self))
        self._CircleDeflection__timeInterval.start()
        isCDVisible = True
        isTracerVisible = False
        self.update()
        self.setVisible(True)


    def destroy(self):
        self.active(False)
        self.setVisible(False)
        self._CircleDeflection__timeInterval.stop()


    def setVisible(self, isVisible):
        self._CircleDeflection__isVisible = isVisible
        self.component.visible = self._CircleDeflection__isVisible


    def setup(self):
        self.target = None
        self.speed = 0
        self.diameter = 0
        self.sectorDiameter = 0


    def update(self):
        if self._CircleDeflection__isVisible != isCDVisible:
            self.setVisible(isCDVisible)

        vehicle = BigWorld.entity(BigWorld.player().playerVehicleID)
        if vehicle is not None:
            if not vehicle.isAlive():
                self.destroy()


        if BigWorld.player().inputHandler.aim != None:
            aimMode = BigWorld.player().inputHandler.aim.mode
        else:
            aimMode = None
        if aimMode == 'strategic':
            if BigWorld.target() != None:
                self.target = BigWorld.target()

            if self.target != None:
                if self.target.isDestroyed == False:
                    self.speed = math.fabs(self.target.getSpeed())
                else:
                    self.target = None

            height = BigWorld.camera().position.y - AvatarInputHandler.control_modes.getFocalPoint()[1]
            if height != 0:
                zoom = 100 / height
            else:
                zoom = 1
            (x, y, z) = BigWorld.player().gunRotator.markerInfo[0]
            v = BigWorld.player().getOwnVehiclePosition() - Math.Vector3(x, y, z)
            dist = v.length
            vTypeDesc = BigWorld.player().vehicleTypeDescriptor
            shellSpeed = vTypeDesc.shot['speed']
            shellGravity = vTypeDesc.shot['gravity']
            maxDist = shellSpeed * shellSpeed / shellGravity
            if dist <= maxDist:
                loc = math.asin(dist * shellGravity / shellSpeed * shellSpeed) * 0.5
            else:
                loc = 0.785398
            shellTime = (math.sin(loc) * shellSpeed / shellGravity) * 2
            self.diameter = shellTime * self.speed * 8.5 * zoom * 2
            if isTracerVisible:
                self.sectorDiameter = 1105.0 * zoom
            else:
                self.sectorDiameter = 0
        else:
            self.diameter = 0
            self.sectorDiameter = 0
        self.flashCall('updateDiameter', [
            self.diameter,
            self.sectorDiameter])


    def flashCall(self, funcName, args = None):
        self.call('CircleDeflection.' + funcName, args)


saved_afterCreate = Battle.afterCreate

def new_afterCreate(self):
    saved_afterCreate(self)
    self.__CircleDeflection = CircleDeflection(weakref.proxy(self))
    self.__CircleDeflection.start()

Battle.afterCreate = new_afterCreate
saved_beforeDelete = Battle.beforeDelete

def new_beforeDelete(self):
    saved_beforeDelete(self)
    self.__CircleDeflection.destroy()

Battle.beforeDelete = new_beforeDelete
saved_handleKey = PlayerAvatar.handleKey

def new_handleKey(self, isDown, key, mods):
    global isCDVisible, isTracerVisible
    cmdMap = CommandMapping.g_instance
    if cmdMap.isFired(CommandMapping.CMD_TOGGLE_GUI, key) and isDown:
        isCDVisible = not isCDVisible

    if key == Keys.KEY_0 and isDown:
        isTracerVisible = not isTracerVisible

    return saved_handleKey(self, isDown, key, mods)

PlayerAvatar.handleKey = new_handleKey