PC PowerPlay 56/CDPowerplay56Disc2.iso/demos/blade/data1.cab/Program_Executable_Files/Lib/Actions.pyc

Python Compiled Bytecode | 2000-10-27 | 90.6 KB | 2,510 lines

# Source Generated with Decompyle++
# File: in.pyc (Python 1.5)

import Bladex
import Ontake
import Stars
import string
import math
import Reference
import Breakings
import InitDataField
import OnInitTake
import AuxFuncs
import B3DLib
import netgame
import Damage
import CharStats
import MenuText
import Netval
import Torchs
import ItemTypes
START_FADEOUT_IN_BIG_FALL = 2.0
END_FADEOUT_IN_BIG_FALL = 2.5
if Reference.DEBUG_INFO == 1:
    import pdb

import pdb
TRUE = 1 == 1
FALSE = 1 != 1
RA_NO_WEAPON = 0
RA_1H_WEAPON = 1
RA_BOW = 2
RA_2H_OBJECT = 3
RA_TORCH = 4
LA_NO_WEAPON = 0
LA_SHIELD = 1
LA_BOW = 2
LA_2H_OBJECT = 2
PI = math.pi
TWOPI = PI * 2
FACINGANGLE = PI * 0.125
BEHINDANGLE = PI * 0.75
B_SOLID_MASK_PERSON = 1
B_SOLID_MASK_FLOOR = 2
B_SOLID_MASK_CAMERA = 4
B_SOLID_MASK_PARTICLES = 8
MESSAGE_START_WEAPON = 7
MESSAGE_STOP_WEAPON = 8
MESSAGE_START_TRAIL = 14
MESSAGE_STOP_TRAIL = 15
InterpWithOff = (0,)
InterpWithOutOff = (1,)
InertialIntrp = (2,)
FixedRFootIntep = (3,)
FixedLFootIntep = (4,)
FixedFootAutoInterp = 5

def ReportMsg(Msg):
    if netgame.GetNetState() == 0:
        import GameText
        GameText.WriteTextAux(MenuText.GetMenuText(Msg), 2.0, 255, 255, 255, [])



def GetListOfObjectsAt(inv, id):
    if inv.GetNumberObjectsAt(id) == 1:
        name = inv.GetObject(id)
        if name:
            return [
                name]
        else:
            return []
    else:
        corray = range(inv.GetNumberObjectsAt(id))
    resulto = []
    for i in corray:
        name = inv.GetObject(id)
        inv.RemoveObject(name)
        ExtendedTakeObject(inv, name)
        resulto.append(name)

    return resulto


def RemoveAllKeys(EntityName):
    me = Bladex.GetEntity(EntityName)
    inv = me.GetInventory()
    keyNames = []
    for j in range(inv.nKeys):
        keyNames.append(inv.GetKey(j))

    for key in keyNames:
        inv.RemoveKey(key)



def RemoveNoTravelObjects(EntityName):
    me = Bladex.GetEntity(EntityName)
    inv = me.GetInventory()
    objname = inv.GetObject(0)
    counterid = 0
    while objname:
        obj = Bladex.GetEntity(objname)
        if obj.Kind in Reference.TravelObjects:
            counterid = counterid + 1
        else:
            inv.RemoveObject(objname)
        objname = inv.GetObject(counterid)


def PutAllInBack(EntityName):
    me = Bladex.GetEntity(EntityName)
    right = me.InvRight
    left = me.InvLeft
    rightback = me.InvRightBack
    leftback = me.InvLeftBack
    inv = me.GetInventory()
    inv.LinkRightHand('')
    inv.LinkLeftHand('')
    inv.LinkBack('')
    if leftback:
        inv.LinkLeftBack(leftback)
    elif not leftback and left:
        inv.LinkLeftBack(left)
    elif leftback and left:
        print 'ERROR - Actions.PutAllInBack -> leftback and left both diff on none!!!'
        inv.LinkLeftBack(leftback)
        print '   Linked only the back one...'

    if rightback:
        inv.LinkRightBack(rightback)
    elif not rightback and right:
        inv.LinkRightBack(right)
    elif rightback and right:
        print 'ERROR - Actions.PutAllInBack -> rightback and right both diff on none!!!'
        inv.LinkRightBack(rightback)
        print '   Linked only the back one...'



def Start_Weapon(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        if inv:
            weapon_name = inv.GetActiveWeapon()
            if weapon_name:
                weapon = Bladex.GetEntity(weapon_name)
                if weapon:
                    weapon.MessageEvent(Reference.MESSAGE_START_WEAPON, 0, 0)






def Stop_Weapon(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        if inv:
            weapon_name = inv.GetActiveWeapon()
            if weapon_name:
                weapon = Bladex.GetEntity(weapon_name)
                if weapon:
                    weapon.MessageEvent(Reference.MESSAGE_STOP_WEAPON, 0, 0)






def Start_Trail(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        if inv:
            weapon_name = inv.GetActiveWeapon()
            if weapon_name:
                weapon = Bladex.GetEntity(weapon_name)
                if weapon:
                    weapon.MessageEvent(Reference.MESSAGE_START_TRAIL, 0, 0)






def Stop_Trail(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        if inv:
            weapon_name = inv.GetActiveWeapon()
            if weapon_name:
                weapon = Bladex.GetEntity(weapon_name)
                if weapon:
                    weapon.MessageEvent(Reference.MESSAGE_STOP_TRAIL, 0, 0)






def GraspString(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        if inv:
            if inv.HoldingBow:
                bow = Bladex.GetEntity(inv.GetBow())

                try:
                    bow.Data.GraspString()
                except AttributeError:
                    print "No string on bow. Do ItemTypes.ItemDefaultFuncs(Bladex.GetEntity('" + bow.Name + "'))"






def UnGraspString(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        if inv:
            if inv.HoldingBow:
                bow = Bladex.GetEntity(inv.GetBow())

                try:
                    bow.Data.UnGraspString()
                except AttributeError:
                    print "No string on bow. Do ItemTypes.ItemDefaultFuncs(Bladex.GetEntity('" + bow.Name + "'))"






def AddQuiver(inv, new_quiver_name):
    new_quiver = Bladex.GetEntity(new_quiver_name)
    for i in range(inv.nQuivers):
        quiver_name = inv.GetQuiver(i)
        quiver = Bladex.GetEntity(quiver_name)
        if quiver.Data.ArrowType == new_quiver.Data.ArrowType:
            inv.SetCurrentQuiver(quiver_name)
            quiver.Data.ReceiveArrows(new_quiver.Data.NumberOfArrows(), inv.Owner)
            new_quiver.SubscribeToList('Pin')
            inv.LinkRightHand('None')
            return None


    inv.AddQuiver(new_quiver_name)
    inv.SetCurrentQuiver(new_quiver_name)
    inv.LinkRightHand('None')
    if inv.HoldingBow:
        inv.LinkBack(new_quiver_name)



def ExtendedTakeObject(inv, Object2TakeName):
    o = Bladex.GetEntity(Object2TakeName)
    if o.Kind in Reference.StackObjects.keys():
        inv.AddObject(Object2TakeName, Reference.StackObjects[o.Kind] - 1)
    else:
        inv.AddObject(Object2TakeName, 0)


def TakeObject(EntityName, Object2TakeName, force_take = TRUE):
    me = Bladex.GetEntity(EntityName)
    inv = me.GetInventory()
    if IsOneTooMany(EntityName, Object2TakeName):
        if force_take:
            DropToMakeRoomFor(EntityName, Object2TakeName)
        else:
            print EntityName + ': Too many objects of this type: ' + Object2TakeName
            return None

    object_flag = Reference.GiveObjectFlag(Object2TakeName)

    try:
        me.Data.RegisterObjectAsTaken(Object2TakeName)
    except:
        if EntityName == 'Player1':
            print Object2TakeName + ' not registered as taken, Players Data class not created yet'


    if object_flag == Reference.OBJ_ITEM:
        ExtendedTakeObject(inv, Object2TakeName)
    elif object_flag == Reference.OBJ_SHIELD:
        inv.AddShield(Object2TakeName)
        if not (me.InvLeftBack) and not (me.InvRightBack) and not (me.InvLeft):
            inv.LinkLeftHand(Object2TakeName)

    elif object_flag == Reference.OBJ_WEAPON:
        flag = Reference.GiveWeaponFlag(Object2TakeName)
        inv.AddWeapon(Object2TakeName, flag)
        if me.InvLeftBack == '' and me.InvRightBack == '' and me.InvRight == '':
            inv.LinkRightHand(Object2TakeName)

    elif object_flag == Reference.OBJ_BOW:
        inv.AddBow(Object2TakeName)
        if not (me.InvLeftBack) and not (me.InvRightBack) and not (me.InvRight) and not (me.InvLeft):
            inv.LinkLeftHand(Object2TakeName)

    elif object_flag == Reference.OBJ_QUIVER:
        AddQuiver(inv, Object2TakeName)
    elif object_flag == Reference.OBJ_STANDARD:
        if not (me.InvLeftBack) and not (me.InvRightBack) and not (me.InvRight):
            inv.LinkRightHand(Object2TakeName)

    elif object_flag == Reference.OBJ_KEY:
        inv.AddKey(Object2TakeName)
    elif object_flag == Reference.OBJ_SPECIALKEY:
        inv.AddSpecialKey(Object2TakeName)
    elif object_flag == Reference.OBJ_TABLET:
        inv.AddTablet(Object2TakeName)
    elif object_flag == Reference.OBJ_ARROW:
        pass
    elif object_flag == Reference.OBJ_USEME and EntityName != 'Player1':
        ExtendedTakeObject(inv, Object2TakeName)
    else:
        print 'ERROR adding an object to a character !!!'
        print 'Not classified properly in Reference.py!!!'


def StatR(EntityName):
    me = Bladex.GetEntity(EntityName)
    ObjectName = me.InvRight
    if ObjectName == 'None' or not ObjectName:
        return RA_NO_WEAPON

    object_flag = Reference.GiveObjectFlag(ObjectName)
    if object_flag == Reference.OBJ_BOW:
        return RA_BOW
    else:
        return RA_1H_WEAPON


def StatL(EntityName):
    me = Bladex.GetEntity(EntityName)
    ObjectName = me.InvLeft
    if ObjectName == 'None' or not ObjectName:
        return LA_NO_WEAPON

    object_flag = Reference.GiveObjectFlag(ObjectName)
    if object_flag == Reference.OBJ_SHIELD:
        return LA_SHIELD
    elif object_flag == Reference.OBJ_BOW:
        return LA_BOW
    else:
        print 'ERROR - Invalid object in left hand!!!'
        print 'Check it in Reference.py!!!'
        return None


def IsRightHandStandardObject(EntityName):
    me = Bladex.GetEntity(EntityName)
    if not (me.InvRight):
        return FALSE

    object_flag = Reference.GiveObjectFlag(me.InvRight)
    return object_flag == Reference.OBJ_STANDARD


def IsRightHandWeaponObject(EntityName):
    me = Bladex.GetEntity(EntityName)
    if not (me.InvRight):
        return FALSE

    object_flag = Reference.GiveObjectFlag(me.InvRight)
    if not object_flag == Reference.OBJ_WEAPON:
        pass
    return object_flag == Reference.OBJ_BOW


def IsRightHandAutomaticObject(EntityName):
    me = Bladex.GetEntity(EntityName)
    if not (me.InvRight):
        return FALSE

    object_flag = Reference.GiveObjectFlag(me.InvRight)
    return object_flag == Reference.OBJ_USEME


def IsBehindEntity(MyName, OtherName):
    them = Bladex.GetEntity(OtherName)
    angle1 = them.Angle
    angle2 = B3DLib.GetEntity2EntityAngle(OtherName, MyName)
    return abs(B3DLib.DiffAngle(angle1, angle2)) >= BEHINDANGLE


def IsFacingEntity(MyName, OtherName):
    me = Bladex.GetEntity(MyName)
    angle1 = me.Angle
    angle2 = B3DLib.GetEntity2EntityAngle(MyName, OtherName)
    return abs(B3DLib.DiffAngle(angle1, angle2)) <= FACINGANGLE


def IsFacingPos(MyName, x, z):
    me = Bladex.GetEntity(MyName)
    angle1 = me.Angle
    p1 = me.Position
    x = x - p1[0]
    z = z - p1[2]
    angle2 = B3DLib.GetXZAngle(x, 0.0, z)
    return abs(B3DLib.DiffAngle(angle1, angle2)) <= FACINGANGLE


def Turn180(MyName):
    me = Bladex.GetEntity(MyName)
    angle = me.Angle + PI
    if angle >= TWOPI:
        angle = angle - TWOPI

    me.Face(angle)


def QuickTurn180(MyName):
    me = Bladex.GetEntity(MyName)
    angle = me.Angle + PI
    if angle >= TWOPI:
        angle = angle - TWOPI

    me.QuickFace(angle)


def TurnToFaceEntity(MyName, OtherName):
    me = Bladex.GetEntity(MyName)
    angle = B3DLib.GetEntity2EntityAngle(MyName, OtherName)
    me.Face(angle)


def TurnToFaceEntityNow(MyName, OtherName):
    me = Bladex.GetEntity(MyName)
    angle = B3DLib.GetEntity2EntityAngle(MyName, OtherName)
    me.Angle = angle


def QuickTurnToFaceEntity(MyName, OtherName):
    me = Bladex.GetEntity(MyName)
    angle = B3DLib.GetEntity2EntityAngle(MyName, OtherName)
    me.QuickFace(angle)


def TurnToFacePos(MyName, x, z):
    me = Bladex.GetEntity(MyName)
    p1 = me.Position
    x = x - p1[0]
    z = z - p1[2]
    angle = B3DLib.GetXZAngle(x, 0.0, z)
    me.Face(angle)


def QuickTurnToFacePos(MyName, x, z):
    me = Bladex.GetEntity(MyName)
    p1 = me.Position
    x = x - p1[0]
    z = z - p1[2]
    angle = B3DLib.GetXZAngle(x, 0.0, z)
    me.QuickFace(angle)

USE_FROM_INV = 0
USE_FROM_NEARBY = 2
USE_FROM_TAKE = 4

def StdUse(EntityName):
    me = Bladex.GetEntity(EntityName)
    if me.Wuea == Reference.WUEA_ENDED:
        return FALSE

    if me.Wuea == Reference.WUEA_WAIT:
        return FALSE

    if me.AnmEndedFunc:
        return FALSE

    TryWithAnother = 1
    if me.Name[0:6] == 'Player' and me.Data.InventoryActive:
        inv = me.GetInventory()
        object_name = inv.GetSelectedObject()
        if object_name:
            object = Bladex.GetEntity(object_name)
            if object and object.CanUse:
                me.Data.obj_used = object
                InitDataField.Initialise(object)
                object.Data.UsedBy = EntityName
                object.UseFunc(object_name, USE_FROM_INV)
                TryWithAnother = 0



    if TryWithAnother:
        if me.Data and me.Data.selected_entity:
            if IsValidForUsing(me.Data.selected_entity[0], EntityName):
                object_flag = Reference.GiveObjectFlag(me.Data.selected_entity[0])
                if object_flag != Reference.OBJ_USEME and object_flag != Reference.OBJ_ITEM:
                    object = Bladex.GetEntity(me.Data.selected_entity[0])
                    me.Data.obj_used = object
                    InitDataField.Initialise(object)
                    object.Data.UsedBy = EntityName
                    object.UseFunc(object.Name, USE_FROM_NEARBY)
                    return None


            if IsValidForTaking(me.Data.selected_entity[0]):
                me.Data.toggle4t_clearback = FALSE
                me.Data.stuff_onback_b4 = SthOnBack(EntityName)
                if TryToTake(EntityName, me.Data.selected_entity[0]):
                    return None

            else:
                ReportMsg('The selected object cannot be taken')
        else:
            ReportMsg('Nothing selected')



def IsValidForUsing(instance_name, EntityName):
    me = Bladex.GetEntity(EntityName)
    object = Bladex.GetEntity(instance_name)
    if not me and not object and not (object.CanUse) or not (object.UseFunc):
        return FALSE

    dist = B3DLib.GetXZDistance(EntityName, instance_name)
    chartype = Bladex.GetCharType(me.CharType, me.CharTypeExt)
    if dist > chartype.Reach * 1.5:
        return FALSE

    heightdiff = -(object.Position[1] - (me.Position[1] + me.Dist2Floor))
    if heightdiff < chartype.MinTake:
        return FALSE

    if heightdiff > chartype.MaxTake5:
        return FALSE

    return TRUE


def has_torch(EntityName):
    me = Bladex.GetEntity(EntityName)
    obj_name = me.InvRight
    if obj_name:
        obj = Bladex.GetEntity(obj_name)
        if obj:
            return obj.Kind == 'Antorcha'


    return 0


def DestroyBurningItem(EntityName, DestroyTime):
    obj = Bladex.GetEntity(EntityName)
    if obj:

        try:
            if not (obj.Data.brkobjdata):
                Breakings.SetBreakable(EntityName, DestroyTime, DestroyTime)
        except:
            Breakings.SetBreakable(EntityName, DestroyTime, DestroyTime)

        brkobj = obj.Data.brkobjdata
        Breakings.ExplodeSpecialObject(EntityName, 3500.0)

    for n in brkobj.n_piezas:
        brkobj.pieza[n].CatchOnFire(0.0, 0.0, 0.0)



def StdSetFireToUseFunc(ObjectName, use_from):
    object = Bladex.GetEntity(ObjectName)
    object.UseFunc = 0
    from_pos = (0.0, 0.0, 0.0)
    if use_from == USE_FROM_INV and use_from == USE_FROM_NEARBY or use_from == USE_FROM_TAKE:
        EntityName = object.Data.UsedBy
        me = Bladex.GetEntity(EntityName)
        if me:
            if not has_torch(EntityName):
                return None

            torch = Bladex.GetEntity(me.InvRight)
            if torch.Data.torchobjdata.LightStatus == Torchs.OFF:
                return None

            object.Data.UsedBy = me.InvRight
            QuickTurnToFaceEntity(EntityName, ObjectName)
            heightdiff = -(object.Position[1] - (me.Position[1] + me.Dist2Floor))
            chartype = Bladex.GetCharType(me.CharType, me.CharTypeExt)
            me.AddAnmEventFunc('SetAlightEvent', SetAlightEventHandler)
            if heightdiff <= chartype.MaxTake1:
                me.LaunchAnmType('fire_g')
            elif heightdiff <= chartype.MaxTake2:
                me.LaunchAnmType('fire0')
            elif heightdiff <= chartype.MaxTake3:
                me.LaunchAnmType('fire1')
            elif heightdiff <= chartype.MaxTake4:
                me.LaunchAnmType('fire2')
            elif heightdiff <= chartype.MaxTake5:
                me.LaunchAnmType('fire3')





def SetAlight(ObjectName):
    object = Bladex.GetEntity(ObjectName)
    if object:

        try:
            UserName = object.Data.UsedBy
            user = Bladex.GetEntity(UserName)
            user_pos = user.Position
        except:
            user_pos = (0.0, 0.0, 0.0)

        object.CatchOnFire(user_pos[0], user_pos[1], user_pos[2])
        if object.Data.BurnTime:
            Bladex.AddScheduledFunc(Bladex.GetTime() + object.Data.BurnTime, DestroyBurningItem, (ObjectName, object.Data.DestroyTime), 'SetAlight' + ObjectName)




def SetBurnable(EntityName, BurnTime, DestroyTime):
    object = Bladex.GetEntity(EntityName)
    object.UseFunc = StdSetFireToUseFunc
    InitDataField.Initialise(object)
    object.Data.BurnTime = BurnTime
    object.Data.DestroyTime = DestroyTime


def SetAlightEventHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    me.DelAnmEventFunc(EventName)
    if EventName != 'SetAlightEvent':
        return None

    object = me.Data.obj_used
    if object:
        SetAlight(object.Name)



def IsValidForTaking(instance_name):
    object = Bladex.GetEntity(instance_name)
    if object:
        if object.Static and object.Weapon and object.WeaponMode == Reference.ACTIVE_WEAPON_MODE:
            return FALSE

        if object.Parent:
            parent = Bladex.GetEntity(object.Parent)
            if parent and parent.Person:
                return FALSE


        object_data = None
        if Reference.EntitiesObjectData.has_key(instance_name):
            object_data = Reference.EntitiesObjectData[instance_name]
        elif Reference.DefaultObjectData.has_key(object.Kind):
            object_data = Reference.DefaultObjectData[object.Kind]

        if not object_data:
            return FALSE

        if object_data[0] == Reference.OBJ_USEME and not (object.CanUse):
            return FALSE


    return TRUE


def IsValidForThrowing(object_name):
    object = Bladex.GetEntity(object_name)
    if object:
        if Reference.EntitiesObjectData.has_key(object_name):
            object_data = Reference.EntitiesObjectData[object_name]
        elif Reference.DefaultObjectData.has_key(object.Kind):
            object_data = Reference.DefaultObjectData[object.Kind]
        else:
            return FALSE
        object_flag = object_data[0]
        if object_flag == Reference.OBJ_WEAPON and object_flag == Reference.OBJ_BOW or object_flag == Reference.OBJ_STANDARD:
            return TRUE


    return FALSE


def IsValidForDropping(ObjectName):
    if Reference.EntitiesObjectData.has_key(ObjectName):
        object_data = Reference.EntitiesObjectData[ObjectName]
    else:
        object = Bladex.GetEntity(ObjectName)
        if not Reference.DefaultObjectData.has_key(object.Kind):
            return TRUE

        object_data = Reference.DefaultObjectData[object.Kind]
    object_flag = object_data[0]
    if object_flag == Reference.OBJ_KEY:
        return FALSE
    elif object_flag == Reference.OBJ_SPECIALKEY:
        return FALSE
    elif object_flag == Reference.OBJ_TABLET:
        return FALSE
    elif object_flag == Reference.OBJ_ITEM:
        return FALSE
    else:
        return TRUE


def GetCheckSelected(func, Data):
    if Data:
        if Data.selected_entity:
            s = Data.selected_entity[0]
            if func(s):
                return s



    return None


def DropToMakeRoomFor(EntityName, ObjectName):
    me = Bladex.GetEntity(EntityName)
    object_flag = Reference.GiveObjectFlag(ObjectName)
    inv = me.GetInventory()
    DropObjectName = None
    if object_flag == Reference.OBJ_ARMOUR:
        print 'Warning DropToMakeRoomFor() unimplimented for Armour...'
    elif object_flag == Reference.OBJ_ITEM:
        ObjectKind = Bladex.GetEntity(ObjectName).Kind
        for i in range(inv.nObjects):
            auxname = inv.GetObject(i)
            if auxname:
                if Bladex.GetEntity(auxname).Kind == ObjectKind:
                    DropObjectName = auxname
                    break

            else:
                break

    elif object_flag == Reference.OBJ_SHIELD:
        DropObjectName = inv.GetShield(0)
    elif object_flag == Reference.OBJ_WEAPON:
        DropObjectName = inv.GetWeapon(0)
    elif object_flag == Reference.OBJ_BOW:
        if inv.HasBow:
            DropObjectName = inv.GetBow()
        else:
            DropObjectName = inv.GetWeapon(0)
    elif object_flag == Reference.OBJ_QUIVER:
        DropObjectName = inv.GetQuiver(0)
    elif object_flag == Reference.OBJ_STANDARD:
        DropObjectName = me.InvRight
    elif object_flag == Reference.OBJ_KEY:
        print 'Warning DropToMakeRoomFor() unimplimented for Keys...'
    elif object_flag == Reference.OBJ_SPECIALKEY:
        print 'Warning DropToMakeRoomFor() unimplimented for Special Keys...'
    elif object_flag == Reference.OBJ_TABLET:
        print 'Warning DropToMakeRoomFor() unimplimented for Tablets...'
    elif object_flag == Reference.OBJ_USEME:
        DropObjectName = me.InvRight
    elif object_flag == Reference.OBJ_ARROW:
        print 'Warning DropToMakeRoomFor() unimplimented for Arrows...'

    if DropObjectName:
        object = Bladex.GetEntity(DropObjectName)
        if object:
            RemoveFromInventory(me, object, 'DropToMakeRoomFor ' + ObjectName)
            object.Position = me.Position
            object.ExcludeHitFor(me)
            if object.TestHit:
                object.RemoveFromWorld()
            else:
                object.Alpha = 1.0
                object.Impulse(0.0, 0.0, 0.0)




def IsOneTooMany(EntityName, ObjectName):
    me = Bladex.GetEntity(EntityName)
    if Reference.EntitiesObjectData.has_key(ObjectName):
        object_data = Reference.EntitiesObjectData[ObjectName]
    else:
        object = Bladex.GetEntity(ObjectName)
        object_data = Reference.DefaultObjectData[object.Kind]
    object_flag = object_data[0]
    ret_val = FALSE
    inv = me.GetInventory()
    if object_flag == Reference.OBJ_ITEM:
        ret_val = inv.nObjects >= inv.maxObjects
        if not ret_val:
            ObjectEntity = Bladex.GetEntity(ObjectName)
            for i in range(inv.nObjects):
                auxname = inv.GetObject(i)
                if auxname:
                    if Bladex.GetEntity(auxname).Kind == ObjectEntity.Kind:
                        ret_val = inv.GetMaxNumberObjectsAt(i) <= inv.GetNumberObjectsAt(i)
                        break

                else:
                    break


    elif object_flag == Reference.OBJ_SHIELD:
        ret_val = inv.nShields >= inv.maxShields
    elif object_flag == Reference.OBJ_WEAPON:
        ret_val = inv.nWeapons >= inv.maxWeapons
    elif object_flag == Reference.OBJ_BOW:
        if not inv.nWeapons >= inv.maxWeapons:
            pass
        ret_val = inv.HasBow
    elif object_flag == Reference.OBJ_QUIVER:
        ret_val = inv.nObjects >= inv.maxObjects
    elif object_flag == Reference.OBJ_STANDARD:
        ret_val = FALSE
    elif object_flag == Reference.OBJ_KEY:
        ret_val = FALSE
    elif object_flag == Reference.OBJ_SPECIALKEY:
        ret_val = FALSE
    elif object_flag == Reference.OBJ_TABLET:
        ret_val = FALSE
    elif object_flag == Reference.OBJ_USEME:
        ret_val = FALSE
    elif object_flag == Reference.OBJ_ARROW:
        ret_val = not CouldSheatheArrow(inv, ObjectName)

    return ret_val


def TryToTake(EntityName, ObjectName):
    me = Bladex.GetEntity(EntityName)
    if me.Wuea == Reference.WUEA_ENDED:
        return FALSE

    if me.Wuea == Reference.WUEA_WAIT:
        return FALSE

    if me.AnmEndedFunc:
        return FALSE

    inv = me.GetInventory()
    if inv.CarringObject(ObjectName):
        return FALSE

    object = Bladex.GetEntity(ObjectName)
    dist = B3DLib.GetXZDistance(EntityName, ObjectName)
    chartype = Bladex.GetCharType(me.CharType, me.CharTypeExt)
    if dist > chartype.Reach:
        ReportMsg('Not in reach')
        return FALSE

    me.Data.last_heightdiff = -(object.Position[1] - (me.Position[1] + me.Dist2Floor))
    if me.Data.last_heightdiff < chartype.MinTake:
        ReportMsg('Too low to pick up')
        return FALSE
    elif me.Data.last_heightdiff > chartype.MaxTake5:
        ReportMsg('Too high to pick up')
        return FALSE
    elif IsOneTooMany(EntityName, ObjectName):
        ReportMsg('Too many objects of this type')
        return FALSE

    QuickTurnToFaceEntity(EntityName, ObjectName)
    me.Data.pickup_entity = ObjectName
    IntermediateTake(EntityName, ObjectName)
    return TRUE


def UnSheatheArrow(inv):
    des_quiver_name = inv.GetSelectedQuiver()
    inv.LinkRightHand('None')
    if des_quiver_name:
        inv.SetCurrentQuiver(des_quiver_name)
        inv.LinkBack('None')
        inv.LinkBack(des_quiver_name)
        quiver = Bladex.GetEntity(des_quiver_name)
        if quiver and quiver.Data.NumberOfArrows() > 0:
            arrow = quiver.Data.GiveArrow()
            if arrow:
                inv.LinkRightHand(arrow.Name)
                return None



    ReportMsg('Out of Arrows')


def CouldSheatheArrow(inv, ArrowName):
    arrow = Bladex.GetEntity(ArrowName)
    for i in range(inv.nQuivers):
        quiver_name = inv.GetQuiver(i)
        quiver = Bladex.GetEntity(quiver_name)

    return TRUE


def SheatheArrow(inv, ArrowName):
    UnGraspString(inv.Owner, 'UnGraspString')
    arrow = Bladex.GetEntity(ArrowName)
    for i in range(inv.nQuivers):
        quiver_name = inv.GetQuiver(i)
        quiver = Bladex.GetEntity(quiver_name)

    new_quiver_type = Reference.GiveQuiverType(arrow.Kind)
    if new_quiver_type:
        new_quiver = Bladex.CreateEntity(new_quiver_type + '_for_' + inv.Owner, new_quiver_type + '_E', 0, 0, 0, 'Physic')
        ItemTypes.ItemDefaultFuncs(new_quiver)
        inv.AddQuiver(new_quiver.Name)
        inv.SetCurrentQuiver(new_quiver.Name)
        if inv.HoldingBow:
            inv.LinkBack(new_quiver.Name)

        new_quiver.Data.SetNumberOfArrows(0, inv.Owner)
        if new_quiver.Data.ReceiveArrow(arrow, inv.Owner):
            inv.LinkRightHand('None')
            return None


    DropReleaseEventHandler(inv.Owner, 'DropRightEvent', FALSE)


def Toggle4TakingEvent(pj_name, event):
    me = Bladex.GetEntity(pj_name)
    inv = me.GetInventory()
    me.DelAnmEventFunc(event)
    if inv.HoldingBow:
        if me.InvRight:
            if Reference.GiveObjectFlag(me.InvRight) == Reference.OBJ_ARROW:
                SheatheArrow(inv, me.InvRight)

        else:
            UnSheatheArrow(inv)
    elif me.InvRightBack and Reference.GiveObjectFlag(me.InvRightBack) != Reference.OBJ_QUIVER:
        if not (me.Data.stuff_onback_b4) and me.Data.toggle4t_clearback:
            tmpr_back = me.InvRightBack
            inv.LinkBack('None')
            inv.LinkRightHand(tmpr_back)
        else:
            inv.LinkRightHand('None')
    elif me.InvRight and not (me.Data.toggle4t_clearback):
        inv.LinkBack(me.InvRight)

    inv.LinkRightHand('None')
    if me.Data.toggle4t_clearback:
        me.Data.toggle4t_clearback = FALSE
        if me.InvLeftBack and Reference.GiveObjectFlag(me.InvLeftBack) == Reference.OBJ_BOW:
            ToggleWEvent(pj_name, event)




def ToggleRight4Taking(EntityName):
    me = Bladex.GetEntity(EntityName)
    if IsRightHandStandardObject(EntityName):
        if TryDropRight(EntityName):
            print 'TryDropRight is ok'
            DropReleaseEventHandler(EntityName, 'DropRightEvent')
            if me.InvRight:
                return FALSE


        me.Wuea = Reference.WUEA_ENDED

    if me.InvRight:
        me.AddAnmEventFunc('ChangeREvent', Toggle4TakingEvent)
        UnGraspString(EntityName, 'UnGraspString')
        me.LaunchAnmType('Chg_r')

    return TRUE


def IntermediateTake(EntityName, ObjectName):
    me = Bladex.GetEntity(EntityName)
    object = Bladex.GetEntity(ObjectName)
    inv = me.GetInventory()
    if inv.CarringObject(ObjectName):
        return None

    if inv.HoldingBow:
        UnGraspString(EntityName, 'UnGraspString')

    if Reference.EntitiesObjectData.has_key(ObjectName):
        object_data = Reference.EntitiesObjectData[ObjectName]
    else:
        object_data = Reference.DefaultObjectData[object.Kind]
    object_flag = object_data[0]
    if object_flag == Reference.OBJ_ARMOUR:
        if me.CharTypeExt != object_data[1]:
            ReportMsg('Type of armour not for me')
            print 'Info is ' + str(object_data[1])
            return None

        if me.Data.armour_level >= object_data[2]:
            ReportMsg('Quality of armour not worthy')
            return None

        if FreeBothHands(EntityName, None, (), 0):
            TakeMainAnm(EntityName)
        else:
            me.AnmEndedFunc = TakeMainAnm

    if object_flag == Reference.OBJ_SHIELD:
        if me.InvRight:
            if ToggleRight4Taking(EntityName) == FALSE:
                return None

            me.AnmEndedFunc = TakeMainAnm
        else:
            TakeMainAnm(EntityName)
    elif object_flag == Reference.OBJ_BOW:
        if me.InvRight:
            if ToggleRight4Taking(EntityName) == FALSE:
                return None

            me.AnmEndedFunc = TakeMainAnm
        else:
            TakeMainAnm(EntityName)
    elif object_flag == Reference.OBJ_WEAPON:
        if me.InvRight:
            if ToggleRight4Taking(EntityName) == FALSE:
                return None

            me.AnmEndedFunc = TakeMainAnm
        else:
            w_flag = Reference.GiveWeaponFlag(ObjectName)
            if me.InvLeft != '' and w_flag != Reference.W_FLAG_1H:
                me.AddAnmEventFunc('ChangeLEvent', Left2InvEvent)
                me.LaunchAnmType('Chg_l')
                me.AnmEndedFunc = TakeMainAnm
            else:
                TakeMainAnm(EntityName)
    elif object_flag == Reference.OBJ_STANDARD:
        if inv.HoldingBow:
            if me.InvRight and Reference.GiveObjectFlag(me.InvRight) == Reference.OBJ_ARROW:
                SheatheArrow(inv, me.InvRight)

            inv.LinkBack(me.InvLeft)
            inv.LinkLeftHand('None')

        if me.InvRight:
            if ToggleRight4Taking(EntityName) == FALSE:
                return None

            me.AnmEndedFunc = TakeMainAnm
        else:
            TakeMainAnm(EntityName)
    elif me.InvRight:
        if ToggleRight4Taking(EntityName) != FALSE:
            me.AnmEndedFunc = TakeMainAnm

    else:
        TakeMainAnm(EntityName)


def ToggleAfterTakeObj(EntityName):
    me = Bladex.GetEntity(EntityName)
    me.AnmEndedFunc = None
    inv = me.GetInventory()
    if IsRightHandStandardObject(EntityName):
        return None

    me.Data.toggle4t_clearback = TRUE
    if me.Data.stuff_onback_b4:
        if SthOnBack(EntityName):
            ToggleRight4Taking(EntityName)
        else:
            ToggleRight4Taking(EntityName)
    else:
        ToggleRight4Taking(EntityName)


def TakeObject2Inv(EntityName):
    me = Bladex.GetEntity(EntityName)
    if not (me.Data) or not (me.Data.pickup_entity):
        return FALSE

    object_flag = Reference.GiveObjectFlag(me.Data.pickup_entity)
    if object_flag == Reference.OBJ_ARROW and me.InvLeft and Reference.GiveObjectFlag(me.InvLeft) == Reference.OBJ_BOW:
        return FALSE

    back_flag = SthOnBack(EntityName)
    if back_flag and object_flag == Reference.OBJ_WEAPON:
        w_flag = Reference.GiveWeaponFlag(me.Data.pickup_entity)
        if w_flag != Reference.W_FLAG_1H:
            back_flag = 0


    weapon_stay = 0
    if not (me.Data.stuff_onback_b4) and not back_flag and object_flag == Reference.OBJ_WEAPON:
        if not (me.InvLeft) or Reference.GiveObjectFlag(me.InvLeft) != Reference.OBJ_BOW:
            weapon_stay = 1


    if object_flag != Reference.OBJ_STANDARD and object_flag != Reference.OBJ_USEME and not weapon_stay:
        return TRUE

    return FALSE


def TakeObject2Left(EntityName):
    me = Bladex.GetEntity(EntityName)
    if me.Data and not (me.Data.pickup_entity == me.InvRight):
        if me.InvRight:
            return FALSE


    if me.Data and me.Data.pickup_entity:
        if not (me.InvLeft):
            object_flag = Reference.GiveObjectFlag(me.Data.pickup_entity)
            if object_flag == Reference.OBJ_SHIELD:
                if TwoHandedWeaponOnBack(EntityName):
                    return FALSE

                if not (me.InvLeftBack):
                    return TRUE


            if object_flag == Reference.OBJ_BOW:
                if not (me.InvLeftBack) and not (me.InvRightBack):
                    return TRUE




    return FALSE


def RemoveRightHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    me.DelAnmEventFunc(EventName)
    inv = me.GetInventory()
    if me.InvRight and Reference.GiveObjectFlag(me.InvRight) == Reference.OBJ_ARROW:
        SheatheArrow(inv, me.InvRight)
    else:
        object_name = me.InvRight
        inv.LinkRightHand('None')

        try:
            if object_name and me.Data.obj2left:
                inv.LinkLeftHand(object_name)

            me.Data.obj2left = None
        except AttributeError:
            pass



def TakeArmour(EntityName):
    me = Bladex.GetEntity(EntityName)
    ObjectName = me.Data.pickup_entity
    object = Bladex.GetEntity(ObjectName)
    if Reference.EntitiesObjectData.has_key(ObjectName):
        object_data = Reference.EntitiesObjectData[ObjectName]
    else:
        object_data = Reference.DefaultObjectData[object.Kind]
    if object_data[0] != Reference.OBJ_ARMOUR:
        print 'ERROR in Actions.TakeArmour , object is not an armour!!!'
        return None

    ct = Bladex.GetCharType(me.CharType, me.CharTypeExt)
    sound = Bladex.CreateSound('..\\..\\Sounds\\cambio-armadura2.wav', EntityName + 'SoundNewArmour')
    sound.Volume = 0.6
    sound.MinDistance = 10000
    sound.MaxDistance = 20000
    sound.PlayStereo()
    right = me.InvRight
    left = me.InvLeft
    rightback = me.InvRightBack
    leftback = me.InvLeftBack
    inv = me.GetInventory()
    inv.LinkRightHand('')
    inv.LinkLeftHand('')
    inv.LinkBack('')
    me.Data.UnlinkAll(EntityName, '')
    me.ResetWounds()
    if object_data[2] == 0:
        me.SetMesh(ct.NoArmour)
    elif object_data[2] == 1:
        me.SetMesh(ct.LowArmour)
    elif object_data[2] == 2:
        me.SetMesh(ct.MedArmour)
    elif object_data[2] == 3:
        me.SetMesh(ct.HighArmour)
    else:
        print 'ERROR in Actions.TakeArmour , armour level!!!'
    if rightback:
        inv.LinkBack(rightback)

    if leftback:
        inv.LinkBack(leftback)

    if right:
        inv.LinkRightHand(right)

    if left:
        inv.LinkLeftHand(left)

    me.Data.armour_level = object_data[2]
    me.Data.armour_prot_factor = object_data[3]
    object.SubscribeToList('Pin')
    me.AnmEndedFunc(EntityName)
    return None


def TakeMainAnm(EntityName):
    me = Bladex.GetEntity(EntityName)
    chartype = Bladex.GetCharType(me.CharType, me.CharTypeExt)
    object_name = me.Data.pickup_entity
    ret = OnInitTake.OnInitTakeFunc(object_name)
    if OnInitTake.InitTakeDictionary.has_key(object_name) and not ret:
        return FALSE

    if not (me.Data.pickup_entity):
        return FALSE

    inv = me.GetInventory()
    if inv.CarringObject(object_name):
        return FALSE

    obj2inv = TakeObject2Inv(EntityName)
    me.Data.obj2left = TakeObject2Left(EntityName)
    if Reference.GiveObjectFlag(object_name) == Reference.OBJ_ARMOUR:
        Bladex.AddScheduledFunc(Bladex.GetTime() + 0.5, AuxFuncs.FadeTo, (0.5, 0.5))
        Bladex.AddScheduledFunc(Bladex.GetTime() + 1.0, TakeArmour, (EntityName,))
    elif me.Data.last_heightdiff <= chartype.MaxTake1:
        if obj2inv:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.AddAnmEventFunc('Key_down', RemoveRightHandler)
            me.LaunchAnmType('tke_r_key00')
        else:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.LaunchAnmType('tke_r_01')
    elif me.Data.last_heightdiff <= chartype.MaxTake2:
        if obj2inv:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.AddAnmEventFunc('Key_down', RemoveRightHandler)
            me.LaunchAnmType('tke_r_key01')
        else:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.LaunchAnmType('tke_r_02')
    elif me.Data.last_heightdiff <= chartype.MaxTake3:
        if obj2inv:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.AddAnmEventFunc('Key_down', RemoveRightHandler)
            me.LaunchAnmType('tke_r_key02')
        else:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.LaunchAnmType('tke_r_03')
    elif me.Data.last_heightdiff <= chartype.MaxTake4:
        if obj2inv:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.AddAnmEventFunc('Key_down', RemoveRightHandler)
            me.LaunchAnmType('tke_r_key03')
        else:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.LaunchAnmType('tke_r_04')
    elif me.Data.last_heightdiff <= chartype.MaxTake5:
        if obj2inv:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.AddAnmEventFunc('Key_down', RemoveRightHandler)
            me.LaunchAnmType('tke_r_key04')
        else:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.LaunchAnmType('tke_r_05')
    else:
        print 'Error in SubTake (last_height_diff) , Actions.py'
        if obj2inv:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.AddAnmEventFunc('Key_down', RemoveRightHandler)
            me.LaunchAnmType('tke_r_key04')
        else:
            me.AddAnmEventFunc('PickupEvent', PickupEventHandler)
            me.LaunchAnmType('tke_r_05')
    if obj2inv:
        me.AnmEndedFunc = TakeStraightRecover
    else:
        me.AnmEndedFunc = MainTake2Inv
    return TRUE


def TakeStraightRecover(EntityName):
    me = Bladex.GetEntity(EntityName)
    me.Data.toggle4t_clearback = TRUE
    if not (me.Data.stuff_onback_b4) and SthOnBack(EntityName) and me.InvRightBack and Reference.GiveObjectFlag(me.InvRightBack) == Reference.OBJ_QUIVER:
        me.AddAnmEventFunc('ChangeREvent', Toggle4TakingEvent)
        UnGraspString(EntityName, 'UnGraspString')
        me.LaunchAnmType('Chg_r')



def MainTake2Inv(EntityName):
    me = Bladex.GetEntity(EntityName)
    if not (me.Data) or not (me.Data.pickup_entity):
        return None

    object_name = me.Data.pickup_entity
    if IsRightHandStandardObject(EntityName):
        return None

    if IsRightHandAutomaticObject(EntityName):
        return None

    object_flag = Reference.GiveObjectFlag(object_name)
    if object_flag == Reference.OBJ_ARROW and me.InvLeft and Reference.GiveObjectFlag(me.InvLeft) == Reference.OBJ_BOW:
        return None

    if not (me.Data.stuff_onback_b4) and not SthOnBack(EntityName) and IsRightHandWeaponObject(EntityName):
        return None

    ToggleAfterTakeObj(EntityName)


def PickupEventHandler(EntityName, EventName, force_take = TRUE):
    me = Bladex.GetEntity(EntityName)
    if EventName != 'PickupEvent':
        return None

    if not (me.Data) or not (me.Data.pickup_entity):
        return None

    if Bladex.GetEntity(me.Data.pickup_entity) == None:
        return None

    object_name = me.Data.pickup_entity
    dist = B3DLib.GetXZDistance(EntityName, object_name)
    chartype = Bladex.GetCharType(me.CharType, me.CharTypeExt)
    if dist > chartype.Reach:
        ReportMsg('Not in reach')
        return FALSE

    object = Bladex.GetEntity(object_name)
    if object.Parent:
        parent = Bladex.GetEntity(object.Parent)
        if parent.Person:
            return None

        parent.Unlink(object)

    Ontake.OnTakeFunc(object_name)
    Stars.DeTwinkle(object_name)
    me.Data.selected_entity = None
    me.DelAnmEventFunc(EventName)
    if IsOneTooMany(EntityName, object_name):
        if force_take:
            DropToMakeRoomFor(EntityName, object_name)
        else:
            print EntityName + ': Too many objects of this type: ' + object_name
            return None

    object_flag = Reference.GiveObjectFlag(object_name)
    inv = me.GetInventory()
    weapon_added = FALSE
    if not (me.InvRight):
        if object_flag == Reference.OBJ_WEAPON:
            flag = Reference.GiveWeaponFlag(object_name)
            inv.AddWeapon(object_name, flag)
            weapon_added = TRUE
            if not (me.Data.NPC) and not me.Data.WasObjectAlreadyTaken(object_name):
                import Scorer
                Scorer.SlideTBS(0)


        inv.LinkRightHand(object_name)

    if object_flag == Reference.OBJ_ITEM:
        ExtendedTakeObject(inv, object_name)
    elif object_flag == Reference.OBJ_SHIELD:
        inv.AddShield(object_name)
    elif object_flag == Reference.OBJ_WEAPON:
        if weapon_added == FALSE:
            flag = Reference.GiveWeaponFlag(object_name)
            inv.AddWeapon(object_name, flag)
            if not (me.Data.NPC) and not me.Data.WasObjectAlreadyTaken(object_name):
                import Scorer
                Scorer.SlideTBS(0)


    elif object_flag == Reference.OBJ_BOW:
        inv.AddBow(object_name)
    elif object_flag == Reference.OBJ_QUIVER:
        AddQuiver(inv, object_name)
    elif object_flag == Reference.OBJ_STANDARD:
        pass
    elif object_flag == Reference.OBJ_KEY:
        inv.AddKey(object_name)
    elif object_flag == Reference.OBJ_SPECIALKEY:
        inv.AddSpecialKey(object_name)
    elif object_flag == Reference.OBJ_TABLET:
        inv.AddTablet(object_name)
    elif object_flag == Reference.OBJ_USEME:
        if IsValidForUsing(object_name, EntityName):
            me.Data.obj_used = Bladex.GetEntity(object_name)
            object = Bladex.GetEntity(object_name)
            object.Data.UsedBy = EntityName
            object.UseFunc(object_name, USE_FROM_TAKE)

    elif object_flag == Reference.OBJ_ARROW and not (inv.HoldingBow):
        pass

    me.Data.RegisterObjectAsTaken(object_name)


def ThrowTime2ThrowForce(throw_pressed):
    curve_f = 3.0
    if throw_pressed < Reference.THROW_TIME_MIN:
        MinThrowForce = Reference.THROW_TIME_MIN / Reference.THROW_TIME_MAX
        MinThrowForce = pow(MinThrowForce, curve_f)
        ThrowForce = (throw_pressed / Reference.THROW_TIME_MIN) * MinThrowForce
    elif throw_pressed < Reference.THROW_TIME_MAX:
        ThrowForce = min(throw_pressed, Reference.THROW_TIME_MAX) / Reference.THROW_TIME_MAX
        ThrowForce = pow(ThrowForce, curve_f)
    else:
        ThrowForce = 1.0
    return ThrowForce


def TestThrowRight(EntityName):
    me = Bladex.GetEntity(EntityName)
    throw_pressed = Bladex.GetTimeActionHeld('Throw')
    if not throw_pressed:
        return None

    if throw_pressed < Reference.THROW_TIME_MIN:
        if netgame.GetNetState() != 2:
            TryDropRight(EntityName)
        else:
            netgame.SendUserString(Netval.NET_GAME_THROW_WEAPON, netgame.GetClientId() + ' ' + `-1`)
    elif netgame.GetNetState() != 2:
        me.Data.ThrowForce = ThrowTime2ThrowForce(throw_pressed)
        StdThrowObject(EntityName)
    else:
        netgame.SendUserString(Netval.NET_GAME_THROW_WEAPON, netgame.GetClientId() + ' ' + `ThrowTime2ThrowForce(throw_pressed)`)


def EnterThrowingMode(EntityName):
    pass


def TestThrowLeft(EntityName):
    me = Bladex.GetEntity(EntityName)
    throw_pressed = Bladex.GetTimeActionHeld('Throw')
    if not throw_pressed:
        return None

    TryDropLeft(EntityName)


def StdThrowObject(EntityName):
    me = Bladex.GetEntity(EntityName)
    statR = StatR(EntityName)
    if statR != RA_NO_WEAPON and statR != RA_BOW:
        object = Bladex.GetEntity(me.InvRight)
        if IsValidForThrowing(object.Name):
            object.ExcludeHitFor(me)
            mass = object.Mass
            if mass <= Reference.LightMassMax:
                me.AddAnmEventFunc('ThrowLightFacingEvent', ThrowReleaseEventHandler)
                me.LaunchAnmType('1tw_l_f')
            else:
                me.AddAnmEventFunc('ThrowHeavyFacingEvent', ThrowReleaseEventHandler)
                me.LaunchAnmType('1tw_h_f')
        else:
            ReportMsg('Cannot be thrown')
            StdDropObject(EntityName)



def RemoveFromInventory(me, object, EventName):
    me.Unlink(object)
    inv = me.GetInventory()
    object_name = object.Name
    if object_name == me.InvRight:
        me.RemoveFromInventRight()

    if object_name == me.InvLeft:
        me.RemoveFromInventLeft()

    object_flag = Reference.GiveObjectFlag(object_name)
    if object_flag == Reference.OBJ_ITEM:
        inv.RemoveObject(object_name)
    elif object_flag == Reference.OBJ_SHIELD:
        inv.RemoveShield(object_name)
    elif object_flag == Reference.OBJ_WEAPON:
        inv.RemoveWeapon(object_name)
    elif object_flag == Reference.OBJ_BOW:
        inv.RemoveBow(object_name)
    elif object_flag == Reference.OBJ_QUIVER:
        inv.RemoveQuiver(object_name)
    elif object_flag == Reference.OBJ_STANDARD:
        pass
    elif object_flag == Reference.OBJ_KEY:
        inv.RemoveKey(object_name)
    elif object_flag == Reference.OBJ_SPECIALKEY:
        inv.RemoveSpecialKey(object_name)
    elif object_flag == Reference.OBJ_TABLET:
        inv.RemoveTablet(object_name)
    elif object_flag == Reference.OBJ_USEME:
        pass



def ThrownWeaponStopFunc(EntityName):
    object = Bladex.GetEntity(EntityName)
    if object:
        object.MessageEvent(MESSAGE_STOP_WEAPON, 0, 0)
        object.MessageEvent(MESSAGE_STOP_TRAIL, 0, 0)

        try:
            if object.Data.PrevHitFunc:
                object.HitFunc = object.Data.PrevHitFunc
                object.Data.PrevHitFunc = None
                object.HitFunc(EntityName)
        except AttributeError:
            pass




def ThrownWeaponInflictHitFunc(EntityName, VictimName, ImpX, ImpY, ImpZ):
    object = Bladex.GetEntity(EntityName)
    victim = Bladex.GetEntity(VictimName)
    print 'Thrown object hitting ' + VictimName
    object.MessageEvent(MESSAGE_STOP_WEAPON, 0, 0)
    if object.Data.PrevInflictHitFunc:
        object.InflictHitFunc = object.Data.PrevInflictHitFunc
        object.Data.PrevInflictHitFunc = None
        object.InflictHitFunc(EntityName, VictimName, ImpX, ImpY, ImpZ)
    else:
        object.InflictHitFunc = 0


def AutoCalcThrow(d, h, V, g):
    g2 = g ** 2
    V2 = V ** 2
    V4 = V ** 4
    d2 = d ** 2
    d4 = d ** 4
    a = h ** 2 + d2
    b = d2 * (-1.0 - h * g / V2)
    c = 0.25 * g2 * d4 / V4
    sq_term = b ** 2 - 4 * a * c
    if sq_term < 0.0:
        print "Auto calc doesn't reach"
        return (-PI * 0.25, 2.0)
    else:
        sq_term = math.sqrt(sq_term)
        k = (-b + sq_term) / (2.0 * a)
        angle = -math.acos(math.sqrt(k))
        time = d / (V * math.cos(angle))
        if abs(h - (V * math.sin(angle) * time + 0.5 * g * time * time)) > 0.001:
            angle = -angle
            time = d / (V * math.cos(angle))

        print 'Auto calc gives angle: ' + `angle` + ' with time: ' + `time`
        return (angle, time)


def ThrowReleaseEventHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if EventName == 'ThrowLeftEvent':
        print 'LeftThrow'
        if me.InvLeft == 'None' or not (me.InvLeft):
            return None

        object = Bladex.GetEntity(me.InvLeft)
    elif me.InvRight == 'None' or not (me.InvRight):
        return None

    object = Bladex.GetEntity(me.InvRight)

    try:
        object.Data.ThrowReleaseEventHandler(me.Name, EventName)
    except AttributeError:
        if object.TestHit:
            return None

        RemoveFromInventory(me, object, EventName)
        F = me.Data.ThrowForce * 34000.0
        if me.InCombat:
            target = Bladex.GetEntity(me.ActiveEnemy)
            target_pos = target.Position
            source_pos = object.Position
            x = target_pos[0] - source_pos[0]
            y = target_pos[1] - source_pos[1]
            z = target_pos[2] - source_pos[2]
            (angle, time) = AutoCalcThrow(math.sqrt(x * x + z * z), y, F / object.Mass, +9800.0)
        elif EventName == 'ThrowLightFacingEvent':
            angle = -PI * 0.0625
        elif EventName == 'ThrowHeavyFacingEvent':
            angle = -PI * 0.125
        else:
            angle = -PI * 0.0625
        impulse = me.Rel2AbsVector(0.0, -math.cos(angle) * F, -math.sin(angle) * F)
        if me.InCombat:
            angle = B3DLib.Pos2PosXZAngle(source_pos[0], source_pos[1], source_pos[2], target_pos[0], target_pos[1], target_pos[2])
            diff_angle = min(max(B3DLib.DiffAngle(angle, me.Angle), -FACINGANGLE), FACINGANGLE)
            (x, y, z) = impulse
            cos_ang = math.cos(diff_angle)
            sin_ang = math.sin(diff_angle)
            impulse = (x * cos_ang - z * sin_ang, y, x * sin_ang + z * cos_ang)

        object.Impulse(impulse[0], impulse[1], impulse[2])
        throw_style = Reference.THR_SPINNING
        if Reference.EntitiesObjectData.has_key(object.Name):
            if Reference.EntitiesObjectData[object.Name][0] == Reference.OBJ_WEAPON or Reference.EntitiesObjectData[object.Name][0] == Reference.OBJ_STANDARD:
                weaponData = Reference.EntitiesObjectData[object.Name]
                if len(weaponData) > 4:
                    throw_style = weaponData[4]


        else:
            kind = Bladex.GetEntity(object.Name).Kind
            if Reference.DefaultObjectData.has_key(kind):
                if Reference.DefaultObjectData[kind][0] == Reference.OBJ_WEAPON or Reference.DefaultObjectData[kind][0] == Reference.OBJ_STANDARD:
                    weaponData = Reference.DefaultObjectData[kind]
                    if len(weaponData) > 4:
                        throw_style = weaponData[4]



        object.ExclusionMask = object.ExclusionMask | B_SOLID_MASK_PERSON
        if throw_style == Reference.THR_SPINNING:
            print object.AngularVelocity
            axis = object.GetDummyAxis('1H_R', 0.0, 1.0, 0.0)
            mass = object.Mass
            print mass
            scale = TWOPI * 10 / mass
            object.AngularVelocity = (axis[0] * scale, axis[1] * scale, axis[2] * scale)

        object.MessageEvent(MESSAGE_START_WEAPON, 0, 0)
        object.MessageEvent(MESSAGE_START_TRAIL, 0, 0)
        InitDataField.Initialise(object)
        object.Data.PrevHitFunc = None
        Bladex.AddScheduledFunc(Bladex.GetTime() + 2.0, ThrownWeaponStopFunc, (object.Name,), 'Stop Weapon: ' + object.Name)
        object.Data.PrevInflictHitFunc = object.InflictHitFunc
        object.InflictHitFunc = ThrownWeaponInflictHitFunc
        object.Data.ThrownBy = me

    me.DelAnmEventFunc(EventName)


def StdDropObject(EntityName):
    me = Bladex.GetEntity(EntityName)
    if TryDropRight(EntityName):
        pass
    elif TryDropLeft(EntityName):
        pass



def TryDropRight(EntityName):
    me = Bladex.GetEntity(EntityName)
    statR = StatR(EntityName)
    if statR != RA_NO_WEAPON:
        object = Bladex.GetEntity(me.InvRight)
        if IsValidForDropping(object.Name):
            object.ExcludeHitFor(me)
            if statR == RA_2H_OBJECT:
                me.AddAnmEventFunc('Drop2HandedEvent', DropReleaseEventHandler)
                me.LaunchAnmType('drp_2o')
                return TRUE
            else:
                me.AddAnmEventFunc('DropRightEvent', DropReleaseEventHandler)
                me.Attack = 0
                me.LaunchAnmType('drp_r')
                return TRUE
        else:
            ReportMsg('Cannot be dropped')
            return FALSE
    else:
        return FALSE


def TryDropLeft(EntityName):
    me = Bladex.GetEntity(EntityName)
    statL = StatL(me.Name)
    if statL != LA_NO_WEAPON and statL != LA_BOW:
        object = Bladex.GetEntity(me.InvLeft)
        if IsValidForDropping(object.Name):
            object.ExcludeHitFor(me)
            me.AddAnmEventFunc('DropLeftEvent', DropReleaseEventHandler)
            me.LaunchAnmType('drp_l')
            return TRUE
        else:
            ReportMsg('Cannot be dropped')
    else:
        return FALSE


def DropReleaseEventHandler(EntityName, EventName, TestHit = TRUE):
    me = Bladex.GetEntity(EntityName)
    if EventName == 'DropLeftEvent':
        object = Bladex.GetEntity(me.InvLeft)
    else:
        object = Bladex.GetEntity(me.InvRight)

    try:
        object.Data.DropReleaseEventHandler(me.Name, EventName)
    except AttributeError:
        if TestHit and object.TestHit:
            return None

        RemoveFromInventory(me, object, EventName)
        if EventName == 'DropLeftEvent':
            impulse = me.Rel2AbsVector(500.0, -750.0, 0.0)
        elif EventName == 'Drop2HandedEvent':
            impulse = me.Rel2AbsVector(0.0, -750.0, 0.0)
        else:
            impulse = me.Rel2AbsVector(-1000.0, -1500.0, 0.0)
        object.Impulse(impulse[0], impulse[1], impulse[2])
        object.ExcludeHitFor(me)
        me.DelAnmEventFunc(EventName)



def SqDistanceToGpj(entity):
    return Gpj.SQDistance2(entity)


def SthOnBack(EntityName):
    me = Bladex.GetEntity(EntityName)
    if me.InvLeftBack:
        return TRUE

    if me.InvRightBack:
        if Reference.GiveObjectFlag(me.InvRightBack) == Reference.OBJ_QUIVER:
            return FALSE
        else:
            return TRUE
    else:
        return FALSE


def TwoHandedWeaponOnBack(EntityName):
    me = Bladex.GetEntity(EntityName)
    if SthOnBack(EntityName) and me.InvRightBack:
        back_object_flag = Reference.GiveObjectFlag(me.InvRightBack)
        if back_object_flag == Reference.OBJ_WEAPON:
            w_flag = Reference.GiveWeaponFlag(me.InvRightBack)
            if w_flag != Reference.W_FLAG_1H:
                return TRUE



    return FALSE


def Left2InvEvent(pj_name, event):
    me = Bladex.GetEntity(pj_name)
    me.DelAnmEventFunc(event)
    inv = me.GetInventory()
    if me.InvLeft:
        inv.LinkLeftHand('None')



def Left2BackEvent(pj_name, event):
    me = Bladex.GetEntity(pj_name)
    me.DelAnmEventFunc(event)
    inv = me.GetInventory()
    if me.InvLeft:
        inv.LinkBack(me.InvLeft)



def ToggleWEvent(pj_name, event):
    me = Bladex.GetEntity(pj_name)
    if event == 'ChangeRLEvent':
        me.DelAnmEventFunc('ChangeRLEvent')
    elif event == 'ChangeREvent':
        me.DelAnmEventFunc('ChangeREvent')
    elif event == 'ChangeLEvent':
        me.DelAnmEventFunc('ChangeLEvent')
    else:
        print 'ToggleWEvent : Unexpected error! \n'
    inv = me.GetInventory()
    tmp_rback = me.InvRightBack
    tmp_lback = me.InvLeftBack
    if tmp_rback:
        if Reference.GiveObjectFlag(tmp_rback) == Reference.OBJ_QUIVER:
            tmp_rback = ''


    something_on_back = SthOnBack(pj_name)
    inv.LinkBack('None')
    add_quiver = 0
    if something_on_back and event == 'ChangeRLEvent' or event == 'ChangeREvent':
        if me.InvRight:
            inv.LinkRightHand('None')

        if tmp_lback and Reference.GiveObjectFlag(tmp_lback) == Reference.OBJ_BOW:
            add_quiver = 1

        if me.InvLeft and Reference.GiveObjectFlag(me.InvLeft) == Reference.OBJ_BOW:
            add_quiver = 1


    if event == 'ChangeRLEvent' or event == 'ChangeREvent':
        if me.InvRight:
            if me.InvLeft and Reference.GiveObjectFlag(me.InvLeft) == Reference.OBJ_BOW and me.InvRight and Reference.GiveObjectFlag(me.InvRight) == Reference.OBJ_ARROW:
                SheatheArrow(inv, me.InvRight)
            else:
                inv.LinkBack(me.InvRight)
        elif inv.HoldingBow:
            des_quiver_name = inv.GetSelectedQuiver()
            if des_quiver_name:
                inv.SetCurrentQuiver(des_quiver_name)
                inv.LinkBack(des_quiver_name)


        if not tmp_rback:
            inv.LinkRightHand('None')
        else:
            inv.LinkRightHand(tmp_rback)
            tmp_rback = ''

    if event == 'ChangeRLEvent' or event == 'ChangeLEvent':
        if tmp_rback:
            print 'Pseudo bug? ERROR , MIRAR'
            inv.LinkBack(tmp_rback)

        if me.InvLeft:
            inv.LinkBack(me.InvLeft)

        if not tmp_lback:
            inv.LinkLeftHand('None')
        else:
            inv.LinkLeftHand(tmp_lback)

    if add_quiver:
        UnSheatheArrow(inv)



def StdToggleWeapons(EntityName):
    me = Bladex.GetEntity(EntityName)
    if me.ActiveEnemy:
        me.SetActiveEnemy('')
        me.Data.time_deactive_enemy = Bladex.GetTime()
        return None

    if me.OnFloor == 0:
        return None

    if me.AnmEndedFunc:
        return FALSE

    inv = me.GetInventory()
    right_standard = IsRightHandStandardObject(EntityName)
    drop_right = 0
    if me.InvLeft and Reference.GiveObjectFlag(me.InvLeft) != Reference.OBJ_BOW and me.InvRightBack:
        if not (me.Attack) and not (me.Block):
            me.AddAnmEventFunc('ChangeLEvent', Left2BackEvent)
            me.LaunchAnmType('Chg_l')
            return None
        else:
            me.AddAnmEventFunc('ChangeREvent', ToggleWEvent)
            me.LaunchAnmType('Chg_r')
            return None
    elif me.InvRight and right_standard == 1:
        if (me.InvLeft or me.InvLeftBack) and me.InvRightBack:
            me.AddAnmEventFunc('ChangeLEvent', ToggleWEvent)
            me.LaunchAnmType('Chg_l')
            return None
        elif (me.InvRight and right_standard == 0 or me.InvRightBack) and me.InvLeft or me.InvLeftBack:
            drop_right = 1
        elif (me.InvRight and right_standard == 0 or me.InvRightBack) and not (me.InvLeft) and not (me.InvLeftBack):
            drop_right = 2
        elif not (me.InvRight) and not (me.InvRightBack) and me.InvLeft or me.InvLeftBack:
            if me.InvLeftBack and Reference.GiveObjectFlag(me.InvLeftBack) == Reference.OBJ_BOW:
                me.AddAnmEventFunc('ChangeRLEvent', ToggleWEvent)
                me.LaunchAnmType('Chg_r_l')
                return None
            else:
                me.AddAnmEventFunc('ChangeLEvent', ToggleWEvent)
                me.LaunchAnmType('Chg_l')
                return None
        else:
            return None
    if drop_right != 0 and IsRightHandStandardObject(EntityName):
        if TryDropRight(EntityName):
            DropReleaseEventHandler(EntityName, 'DropRightEvent')

        me.Wuea = Reference.WUEA_ENDED

    if drop_right == 1:
        me.AddAnmEventFunc('ChangeRLEvent', ToggleWEvent)
        me.LaunchAnmType('Chg_r_l')
    elif drop_right == 2:
        me.AddAnmEventFunc('ChangeREvent', ToggleWEvent)
        me.LaunchAnmType('Chg_r')
    else:
        print 'ERROR - ToggleW'


def FreeBothHands(EntityName, CallBack = None, Params = (), ForceNow = 1):
    me = Bladex.GetEntity(EntityName)
    if IsRightHandStandardObject(EntityName):
        if TryDropRight(EntityName):
            DropReleaseEventHandler(EntityName, 'DropRightEvent')

        me.Wuea = Reference.WUEA_ENDED

    if me.InvRight or me.InvLeft:
        if ForceNow:
            me.Wuea = Reference.WUEA_ENDED
            me.SetTmpAnmFlags(1, 1, 1, 0, 5, 1, 0)
            me.LaunchAnmType('rlx')
            me.Wuea = Reference.WUEA_ENDED
            me.SetTmpAnmFlags(1, 1, 1, 0, 5, 1, 0)

        StdToggleWeapons(EntityName)
        if CallBack:
            Bladex.AddScheduledFunc(Bladex.GetTime() + 2.0, CallBack, Params)

        return 0

    if CallBack:
        Bladex.AddScheduledFunc(Bladex.GetTime() + 0.1, CallBack, Params)

    return 1


def RelaxTurn180(EntityName):
    me = Bladex.GetEntity(EntityName)
    me.LaunchAnmType('rlx_turn')


def FrwdDown(EntityName):
    me = Bladex.GetEntity(EntityName)
    if netgame.GetNetState() != 2:
        if me.InCombat:
            return None


    diff = Bladex.GetTime() - me.Data.last_frwdup
    if diff > 0.0 and diff < 0.125:
        me = Bladex.GetEntity(EntityName)
        me.Run = 1



def FrwdUp(EntityName):
    me = Bladex.GetEntity(EntityName)
    if netgame.GetNetState() != 2:
        if me.InCombat:
            return None


    me.Data.last_frwdup = Bladex.GetTime()
    if me.Gob == FALSE:
        me.Run = 0



def BrwdDown(EntityName):
    me = Bladex.GetEntity(EntityName)
    if netgame.GetNetState() != 2:
        if me.InCombat:
            return None


    diff = Bladex.GetTime() - me.Data.last_brwdup
    if diff > 0.0 and diff < 0.125:
        me = Bladex.GetEntity(EntityName)
        me.Run = 1



def BrwdUp(EntityName):
    me = Bladex.GetEntity(EntityName)
    if netgame.GetNetState() != 2:
        if me.InCombat:
            return None


    me.Data.last_brwdup = Bladex.GetTime()
    if me.Gof == FALSE:
        me.Run = 0



def TakeArrowEventHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me:
        inv = me.GetInventory()
        UnSheatheArrow(inv)



def CurrentlyBowing(EntityName):
    me = Bladex.GetEntity(EntityName)
    anm = me.AnimName
    if not anm == 'B1' and anm == 'B2' and anm == 'B3' and anm == 'b1' and anm == 'b2':
        pass
    return anm == 'b3'


def InitBowing(EntityName):
    me = Bladex.GetEntity(EntityName)
    cam = Bladex.GetEntity('Camera')
    if EntityName == 'Player1':

        try:
            if me.Data.LastPViewType == None:
                me.Data.LastPViewType = cam.PViewType
        except AttributeError:
            me.Data.LastPViewType = cam.PViewType


        try:
            if me.Data.LastReturns == None:
                me.Data.LastReturns = me.Returns
        except AttributeError:
            me.Data.LastReturns = me.Returns

        cam.PViewType = 3

    me.Returns = 0
    me.Aim = 1
    me.Data.AimPressed = 1
    me.Accuracy = CharStats.GetCharAccuracy(me.Kind, me.Level)
    me.AimOffTarget = TWOPI


def TestDrawBow(EntityName):
    me = Bladex.GetEntity(EntityName)
    if me.Aim == 0 or not CurrentlyBowing(EntityName):
        if me.InvLeft and Reference.GiveObjectFlag(me.InvLeft) == Reference.OBJ_BOW:
            if me.Wuea == Reference.WUEA_WAIT:
                if me.AnimName[:3] == 'Rlx' or me.AnimName[:3] == 'rlx':
                    me.Wuea = Reference.WUEA_NONE
                else:
                    return None

            if me.InvRight and Reference.GiveObjectFlag(me.InvRight) == Reference.OBJ_ARROW:
                InitBowing(EntityName)
                GraspString(EntityName, 'GraspString')
                me.SetTmpAnmFlags(1, 0, 1, 1, 2, 0)
                me.LaunchAnmType('b1')
                arrow = Bladex.GetEntity(me.InvRight)
                tensar_sound = Bladex.CreateEntity(arrow.Name + 'RedrawSound', 'Entity Sound', 0, 0, 0)
                tensar_sound.SetSound('..\\..\\Sounds\\M-CREAKCUERDA-3b.wav')
                tensar_sound.MinDistance = 5000
                tensar_sound.MaxDistance = 10000
                arrow.Link(tensar_sound)
                tensar_sound.PlaySound(0)
            elif not CurrentlyBowing(EntityName):
                inv = me.GetInventory()
                des_quiver_name = inv.GetSelectedQuiver()
                if des_quiver_name:
                    inv.SetCurrentQuiver(des_quiver_name)
                    inv.LinkBack(des_quiver_name)
                    quiver = Bladex.GetEntity(des_quiver_name)
                    if quiver and quiver.Data.NumberOfArrows() > 0:
                        InitBowing(EntityName)
                        if me.Wuea == Reference.WUEA_WAIT:
                            print 'Trying to draw bow during other animation, wait and try again'
                        else:
                            me.LaunchAnmType('b2')







def EndBowMode(EntityName):
    me = Bladex.GetEntity(EntityName)

    try:
        if me.Data.LastPViewType != None:
            cam = Bladex.GetEntity('Camera')
            cam.PViewType = me.Data.LastPViewType
            me.Data.LastPViewType = None
    except AttributeError:
        pass


    try:
        if me.Data.LastReturns != None:
            me.Returns = me.Data.LastReturns
            me.Data.LastReturns = None
    except AttributeError:
        pass

    me.Aim = 0
    me.Data.AimPressed = 0


def TestReleaseArrow(EntityName):
    me = Bladex.GetEntity(EntityName)
    me.Data.AimPressed = 0
    if not CurrentlyBowing(EntityName):
        EndBowMode(EntityName)



def EndDrawBowEventHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me.Data.AimPressed == 0:
        me.Aim = 0
        arrow = Bladex.GetEntity(me.InvRight)
        if arrow:
            me.Unlink(arrow)
            me.RemoveFromInventRight()
            UnGraspString(EntityName, 'UnGraspString')
            arrow.ExcludeHitFor(me)
            arrow.PutToWorld()
            if me.Data.NPC:
                (vx, vy, vz) = me.AimVector
            else:
                (vx, vy, vz) = arrow.Rel2AbsVector(0, 0, -40000)
            arrow.Fly(vx, vy, vz)
            arrow.MessageEvent(MESSAGE_START_WEAPON, 0, 0)
            arrow.MessageEvent(MESSAGE_START_TRAIL, 0, 0)
            InitDataField.Initialise(arrow)
            Bladex.AddScheduledFunc(Bladex.GetTime() + 2.0, ThrownWeaponStopFunc, (arrow.Name,), 'Stop Weapon: ' + arrow.Name)
            arrow.Data.PrevInflictHitFunc = arrow.InflictHitFunc
            arrow.InflictHitFunc = ThrownWeaponInflictHitFunc
            arrow.Data.ThrownBy = me
            soltar_sound = Bladex.CreateEntity(arrow.Name + 'FlySound', 'Entity Sound', 0, 0, 0)
            soltar_sound.SetSound('..\\..\\Sounds\\ARCO-DISPARO-3.wav')
            soltar_sound.MinDistance = 5000
            soltar_sound.MaxDistance = 10000
            arrow.Link(soltar_sound)
            soltar_sound.PlaySound(0)
            me.SetTmpAnmFlags(1, 0, 1, 1, 2, 0)
            me.LaunchAnmType('b2')
            return None


    me.LaunchAnmType('b3')


def CheckRefireBowEventHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me.Data.AimPressed and me.InvRight:
        arrow = Bladex.GetEntity(me.InvRight)
        if arrow:
            GraspString(EntityName, 'GraspString')
            me.DoActionWI('b1', FixedFootAutoInterp, 0.3, 0.9)
            tensar_sound = Bladex.CreateEntity(arrow.Name + 'RedrawSound', 'Entity Sound', 0, 0, 0)
            tensar_sound.SetSound('..\\..\\Sounds\\M-CREAKCUERDA-4.wav')
            tensar_sound.MinDistance = 5000
            tensar_sound.MaxDistance = 10000
            arrow.Link(tensar_sound)
            tensar_sound.PlaySound(0)
            return None


    EndBowMode(EntityName)


def EndReloadBowEventHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me.Aim:
        me.DoAction('b1')
    elif not (me.InvRight):
        TakeArrowEventHandler(EntityName, EventName)

    me.LaunchAnmType('Rlx_b')


def FadeMeOut(EntityName, timer):
    if EntityName == 'Player1':
        return None

    me = Bladex.GetEntity(EntityName)
    current_alpha = me.Alpha
    if current_alpha > 0.0:
        current_alpha = current_alpha - 0.02
    else:
        me.Life = 0
        me.RemoveFromList('Timer60')
    if current_alpha < 0:
        current_alpha = 0

    me.Alpha = current_alpha
    if me.InvRight:
        right = Bladex.GetEntity(me.InvRight)
        right.Alpha = current_alpha

    if me.InvLeft:
        left = Bladex.GetEntity(me.InvLeft)
        left.Alpha = current_alpha

    if me.InvRightBack:
        right2 = Bladex.GetEntity(me.InvRightBack)
        right2.Alpha = current_alpha

    if me.InvLeftBack:
        left2 = Bladex.GetEntity(me.InvLeftBack)
        left2.Alpha = current_alpha



def ClientCallBack(id, type, cad):
    if type == Netval.NET_GAME_FADE_DUE2BIGFALL:
        if netgame.GetClientId() == cad:
            AuxFuncs.FadeTo(START_FADEOUT_IN_BIG_FALL, END_FADEOUT_IN_BIG_FALL)




def ServerCallBack(id, type, cad):
    if type == Netval.NET_GAME_THROW_WEAPON:
        if netgame.GetNetState() == 1:
            params = string.split(cad)
            me = Bladex.GetEntity(params[0])
            coso = string.atof(params[1])
            if coso == -1:
                TryDropRight(params[0])
            else:
                me.Data.ThrowForce = coso
                StdThrowObject(params[0])




def StartFadingOutPlayer(EntityName):
    me = Bladex.GetEntity(EntityName)
    net_state = netgame.GetNetState()
    if net_state == 0:
        if EntityName == 'Player1' and me.WillCrashInFloor == 0:
            AuxFuncs.FadeTo(START_FADEOUT_IN_BIG_FALL, END_FADEOUT_IN_BIG_FALL)

    elif EntityName == 'Player1':
        if me.WillCrashInFloor == 0:
            AuxFuncs.FadeTo(START_FADEOUT_IN_BIG_FALL, END_FADEOUT_IN_BIG_FALL)

        netgame.SendUserString(Netval.NET_GAME_FADE_DUE2BIGFALL, EntityName)
    else:
        netgame.SendUserString(Netval.NET_GAME_FADE_DUE2BIGFALL, EntityName)
        me.TimerFunc = FadeMeOut
        me.SubscribeToList('Timer60')


def EndFadingOutPlayer(EntityName):
    me = Bladex.GetEntity(EntityName)
    me.Life = 0
    net_state = netgame.GetNetState()
    me.Wuea = Reference.WUEA_ENDED
    if net_state == 0:
        me.ImDeadFunc(me.Name)
        if EntityName == 'Player1':
            if me.WillCrashInFloor == 0:
                int_pos = me.InitPos
                me.Position = (int_pos[0], int_pos[1], int_pos[2])
            else:
                int_pos = me.InitPos
                me.Position = (int_pos[0], int_pos[1], int_pos[2])

    elif net_state == 1:
        me.Alpha = 1.0
        Damage.PlayerHitFunc(me.Name, 'BigFall', me.Life, 1)
    elif net_state == 2:
        me.Alpha = 1.0
    else:
        print 'Actions.py->EndFadingOutPlayer error . Unknown GetNetState()!!!'


def BackUpEnemy(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    me.Data.TmpEnemy = me.ActiveEnemy


def Swap180Handler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me.Data and me.Data.TmpEnemy and me.Data.TmpEnemy == me.ActiveEnemy:
        me.SetActiveEnemy(None)
        if me.Data.selected_enemy:
            ene = Bladex.GetEntity(me.Data.selected_enemy[0])
            if me and ene.Person:
                me.SetActiveEnemy(ene)


    elif me.Data.selected_enemy:
        ene = Bladex.GetEntity(me.Data.selected_enemy[0])
        if me and ene.Person:
            me.SetActiveEnemy(ene)




def EndTransitionFllHugeHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    Bladex.AddScheduledFunc(Bladex.GetTime() + 0.2, StartFadingOutPlayer, (EntityName,), 'StartFadingOutPlayer ' + EntityName)
    me.AnmEndedFunc = TakeMainAnm = EndFadingOutPlayer


def W2hToLeftHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    ObjectName = me.InvRight
    if ObjectName == 'None' or not ObjectName:
        print 'W2hToLeftHandle-> Event in a unexpected situation!!! Entity ' + EntityName + ' in animation ' + me.AnimName
        return None

    inv = me.GetInventory()
    inv.LinkRightHand('None')
    object = Bladex.GetEntity(ObjectName)
    node = me.GetNodeIndex('L_Hand')
    me.LinkToNode(object, node)
    me.Data.TmpW2h = ObjectName


def W2hToRightHandler(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if not ('TmpW2h' in dir(me.Data)):
        me.Data.TmpW2h = ''
        return None

    if me.Data.TmpW2h == None:
        return None

    if me.Data.TmpW2h == '':
        return None

    inv = me.GetInventory()
    object = Bladex.GetEntity(me.Data.TmpW2h)
    me.Unlink(object)
    inv.LinkLeftHand('None')
    inv.LinkRightHand(me.Data.TmpW2h)
    me.Data.TmpW2h = ''


def AutoTake(EntityName):
    me = Bladex.GetEntity(EntityName)
    if me.InvRight:
        if not FreeBothHands(EntityName, None, (), 0):
            return None


    head_pos = me.Rel2AbsPoint(0.0, 0.0, 0.0)
    pj_dir = me.Rel2AbsVector(0.0, -1.0, 0.0)
    list = Bladex.GetObjectEntitiesVisibleFrom(head_pos, 5000.0, pj_dir, 0.0)
    for n in list:
        o = Bladex.GetEntity(n)



def ToggleIAttackRight(EntityName, event):
    me = Bladex.GetEntity(EntityName)
    if not (me.InvRightBack) or me.InvRightBack == '':
        print 'Error in Actions.ToggleIAttackRight'
        return None

    inv = me.GetInventory()
    tmpr_back = me.InvRightBack
    inv.LinkRightBack('None')
    inv.LinkRightHand(tmpr_back)
    if not (me.InCombat):
        import DefaultSelectionData
        DefaultSelectionData.SelectEnemy()



def ToggleIAttackLeft(EntityName, event):
    me = Bladex.GetEntity(EntityName)
    if not (me.InvLeftBack) or me.InvLeftBack == '':
        return None

    inv = me.GetInventory()
    tmpl_back = me.InvLeftBack
    inv.LinkLeftBack('None')
    inv.LinkLeftHand(tmpl_back)


def InstantAttackSlow(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if not (me.Data.NPC) and me.GotAnmType('g_draw_rlx'):
        me.AddAnmEventFunc('ChangeREvent', ToggleIAttackRight)
        me.AddAnmEventFunc('ChangeLEvent', ToggleIAttackLeft)
        me.AttackFunc(EntityName, 'g_draw_rlx')
    elif not (me.Data.NPC):
        print 'No instant attack for not having the animation!! ----3D Dept---' + EntityName



def InstantAttackRun(EntityName, EventName):
    me = Bladex.GetEntity(EntityName)
    if me.GotAnmType('g_draw_run'):
        me.AddAnmEventFunc('ChangeREvent', ToggleIAttackRight)
        me.AddAnmEventFunc('ChangeLEvent', ToggleIAttackLeft)
        me.AttackFunc(EntityName, 'g_draw_run')
    elif me.Data.NPC == 0:
        print 'No instant attack for not having the animation!! ----3D Dept---' + EntityName



def LinkContinuosSoundAux(csound):
    csound.PlaySound(-1)


def LinkContinuosSound(EntityName, SoundName, max_dist = 12000, min_dist = 5000):
    me = Bladex.GetEntity(EntityName)
    csound = Bladex.CreateEntity(EntityName + 'ContinuosSound', 'Entity Sound', 0, 0, 0)
    csound.SetSound(SoundName)
    csound.MinDistance = min_dist
    csound.MaxDistance = max_dist
    me.Link(csound)
    Bladex.AddScheduledFunc(Bladex.GetTime() + 1.0, LinkContinuosSoundAux, (csound,), 'LinkContinuosSoundAux')


def CicloDeluz(PersonName, val):
    per = Bladex.GetEntity(PersonName)
    if per:
        if val < 1.0:
            per.SelfIlum = val
            Bladex.AddScheduledFunc(Bladex.GetTime() + 0.1, CicloDeluz, (PersonName, val + 0.1))
            wps = Bladex.GetEntity(PersonName + 'WPS')
            if wps:
                wps.PPS = wps.PPS + 25

        elif val < 2.0:
            per.Alpha = -val + 1.9
            Bladex.AddScheduledFunc(Bladex.GetTime() + 0.1, CicloDeluz, (PersonName, val + 0.1))




def HumoDeFuego(PersonName):
    per = Bladex.GetEntity(PersonName)
    if per:
        wps = Bladex.CreateEntity(PersonName + 'WPSmk', 'Entity Particle System Dperson', 0.0, 0.0, 0.0)
        wps.PersonName = PersonName
        wps.ParticleType = 'DarkSmoke'
        wps.Time2Live = 96
        wps.RandomVelocity = 0
        wps.Velocity = (0, 0, 0)
        wps.NormalVelocity = 5
        wps.YGravity = 0
        wps.PPS = 125
        wps.DeathTime = Bladex.GetTime() + 1.0



def FreezeMeGuy(PersonName):
    per = Bladex.GetEntity(PersonName)
    per.Freeze()
    per.RemoveFromWorld()


def RePutTheFuckingEndFunction(PersonName):
    per = Bladex.GetEntity(PersonName)
    per.AnmEndedFunc = FreezeMeGuy


def FireDeath(PersonName = 'Player1', ParType = 'LargeFire', NumPart = 32):
    TIME_TO_FIRE = 12.0
    per = Bladex.GetEntity(PersonName)
    if per:
        wps = Bladex.CreateEntity(PersonName + 'WPS', 'Entity Particle System Dperson', 0.0, 0.0, 0.0)
        wps.PersonName = PersonName
        wps.ParticleType = ParType
        wps.Time2Live = NumPart
        wps.RandomVelocity = 1.0
        wps.Velocity = (0, -300, 0)
        wps.NormalVelocity = 3
        wps.YGravity = 0
        wps.PPS = 200
        wps.DeathTime = Bladex.GetTime() + TIME_TO_FIRE
        per.SelfIlum = 0.0
        per.Alpha = 1.0
        Bladex.AddScheduledFunc(Bladex.GetTime() + TIME_TO_FIRE - 2, CicloDeluz, (PersonName, 0))
        Bladex.AddScheduledFunc(Bladex.GetTime() + TIME_TO_FIRE - 0, HumoDeFuego, (PersonName,))
        Bladex.AddScheduledFunc(Bladex.GetTime() + 1.5, RePutTheFuckingEndFunction, (PersonName,))
        per.LaunchAnmType('dth_burn')
        per.AnmEndedFunc = FreezeMeGuy



def ToggleInvincibility():
    me = Bladex.GetEntity('Player1')

    try:
        if me:
            if not (me.Data.Invincibility):
                import pocimac
                me.Life = CharStats.GetCharMaxLife(me.Kind, me.Level)
                pocimac.RestoreWoundsToLifeLevel(me.Name)
                me.Data.Invincibility = TRUE
                ReportMsg('Enabling INVINCIBILITY mode')
            else:
                me.Data.Invincibility = FALSE
                ReportMsg('Disabling INVINCIBILITY mode')
    except AttributeError:
        pass


profiler_on = 1

def ToggleProfiling():
    global profiler_on
    profiler_on = not profiler_on
    if not profiler_on:
        print 'Switching off Profiler'
        Bladex.SetCallCheck(3)
        Bladex.SaveProfileData('Profile.txt')
        Bladex.StartProfile()
        Bladex.DisableProfiler()
    else:
        print 'Switching on Profiler'
        Bladex.SetCallCheck(11)
        Bladex.EnableProfiler()
        Bladex.StartProfile()