class ArtifactTripleDamage extends RPGArtifact;

#exec OBJ LOAD FILE=..\sounds\RPGSound.uax

var config float TargetRadius;
var config int DamagePerHit;

var config int ExtraCostPerPlayer;
var config int ExtraCostPerMine;

var config bool bMustBeMoving;

var localized string NotWithTransMessage;

var Weapon LastWeapon;
var config float DoubleDamageScale;
var Emitter LightningAura;
var int Retry;
var localized string OnlySolidGroundText;

var Emitter Aura;
var config float SpeedScaling;
var float ClassicSpeedScaling;
var int FlagTime;

var XRelics XMutator;
var bool bClassic,bDrop;
var int HUDIconX,HUDIconY;
var PlayerController PlayerOwner;
var HudOverlay XHudOverlay;
var class<Pickup> PickupClassB;
var class<XRelicsHudOverlay> XHudOverlayClass;
var class<XRelicsEmitter> XEmitterClass;

function BotFightEnemy(Bot Bot)
{
       local float Chance;

       if(Vehicle(Instigator) != None)
          return;

       if(!bActive)
       {

          if(HasActiveArtifact(Instigator))
             return;
                 
          if(WeaponLightningConduction(Bot.Enemy.Weapon) != None)
             return;
           
          if(
             Bot.bEnemyIsVisible &&
             Bot.CombatStyle >= 0 &&
             Bot.Skill >= 0 &&     
             Bot.Adrenaline >= 50 &&
             VSize(Bot.Enemy.Location - Instigator.Location) <= TargetRadius)
          {
             Chance = FMin(0.4, (Bot.StrafingAbility + 1.f) / 4.f);
             Chance += 0.05 * (Bot.Skill - 3); //max 0.6
                 
             if(Bot.Enemy.PlayerReplicationInfo != None &&
                Bot.Enemy.PlayerReplicationInfo.HasFlag != None)
                Chance += 0.15; //max 0.75
                    
             if(TransLauncher(Bot.Enemy.Weapon) != None)
                Chance += 0.1; //max 0.85
                 
             if(Instigator.HasUDamage())
                Chance += 0.75; //max 1.1
              
             if(FRand() < Chance)
                Activate();
          }
       }
       else
       {
          if(
             WeaponLightningConduction(Bot.Enemy.Weapon) != None ||
             VSize(Bot.Enemy.Location - Instigator.Location) > TargetRadius)
          {
             Activate();
          }
       }
}

function BotWhatNext(Bot Bot)
{
       if(bActive && (Bot.Enemy == None || !Bot.bEnemyIsVisible))
          Activate();
}

function BotLoseEnemy(Bot Bot)
{
       if(bActive)
          Activate(); //deactivate
}

function bool CanActivate()
{
       if(class'ArtifactTripleDamage'.static.IsActiveFor(Instigator))
       {
          return false;
       }

       if(Instigator.HasUDamage())
          return false;
              
       return Super.CanActivate();
}

state Activated
{
       function BeginState()
       {
          Super.BeginState();
           
          Instigator.DamageScaling *= DoubleDamageScale;
          Instigator.PlaySound(Sound'RPGSound.Triple', SLOT_None, 2.5*Instigator.TransientSoundVolume,,1000,2.5);
              
                    LightningAura = Instigator.spawn(class'LightningAura2', Instigator);
          Retry = 0;
          Timer();
          SetTimer(0.5, true);
       }
           
       function Timer()
       {
          local float EstimatedTimeLeft;
          local Pawn P;
              
          if(Vehicle(Instigator) != None)
             P = Vehicle(Instigator).Driver;
          else
             P = Instigator;
              
          if(P != None)
          {
             EstimatedTimeLeft = Instigator.Controller.Adrenaline / CostPerSec;
                 
             P.EnableUDamage(EstimatedTimeLeft);
             if(xPawn(P) != None)
             {
                if(TripleDamageTimer(xPawn(P).UDamageTimer) == None)
                {
                   if(xPawn(P).UDamageTimer != None)
                      xPawn(P).UDamageTimer.Destroy();

                   xPawn(P).UDamageTimer = Spawn(class'TripleDamageTimer', P);
                }
                xPawn(P).UDamageTimer.SetTimer(xPawn(P).UDamageTime - Level.TimeSeconds - 3, false);
             }
          }
       }
           
       function EndState()
       {
          local Pawn P;
              
          if(Vehicle(Instigator) != None)
             P = Vehicle(Instigator).Driver;
          else
             P = Instigator;

          SetTimer(0, false);
          if (P != None)
          {
             Instigator.DamageScaling /= DoubleDamageScale;

             P.DisableUDamage();
                 
             if(xPawn(P) != None && xPawn(P).UDamageTimer != None)
                xPawn(P).UDamageTimer.Destroy();
          }

                        
               if (LightningAura != None)
                  LightningAura.Destroy();
                        
              
          Super.EndState();
       }
}

function DropFrom(vector StartLocation) {
        local Pawn P;
        local PlayerReplicationInfo PRI;
        if (!bClassic) {
           P=Pawn(Owner);
           if (P!=none && P.Controller!=none) {
              PRI=P.Controller.PlayerReplicationInfo;
              if (PRI!=none && PRI.HasFlag!=none) {
                 PRI.HasFlag.Drop(vect(0,0,0));
              }
           }
        }
        super.DropFrom(StartLocation);
}

function PickupFunction(Pawn Other) {
        StartEffect(Other);
}

function StartEffect(Pawn P) {
        if (bClassic) {
           SpeedScaling=ClassicSpeedScaling;
        }
        Aura=Spawn(class 'TitanRPG160-Update2.FX_AdrenAura',P,,P.Location,P.Rotation);
        if (!bClassic) {
           SetTimer(2.0,true);
        }
}

function Timer() {
        local Pawn P;
        local PlayerReplicationInfo PRI;
        local int RandomTime;
        P=Pawn(Owner);
        if (P!=none && P.Controller!=none) {
           PRI=P.Controller.PlayerReplicationInfo;
           if (PRI!=none && PRI.HasFlag!=none) {
              RandomTime=Rand(15);
              FlagTime=FlagTime+2;
              if (FlagTime>RandomTime) {
                 bDrop=false;
                 Destroy();
              }
           }
        }
}

function StopEffect(Pawn P) {
        if (Aura!=none) {
           Aura.Destroy();
        }
        SetTimer(0,false);
}

defaultproperties
{
         DoubleDamageScale=0.400000
         CostPerSec=10
         MinActivationTime=10.000000
         HudColor=(B=128,G=0)
         UseDelay=30.000000
         ArtifactID="Triple"
         Description="Использование увеличивает атаки вдвое."
         PickupClass=Class'TitanRPG160-Update2.ArtifactPickupTripleDamage'
         IconMaterial=Texture'TitanRPG160-Update2.ArtifactIcons.Triple'
         ItemName="Бойня"
}

class RPGArtifact extends Powerups
     config(TitanRPG);

const USE_DELAY_SWITCH = 8000;

var config int CostPerSec; //default adrenaline cost per second
var config float MinActivationTime; //zero means single hit usage (e.g. Repulsion)
var config int MinAdrenaline; //adrenaline required to activate this artifact

var config Color HudColor;

var config float UseDelay; //how much time has to pass before you can use this first / again

var float CurrentCostPerSec;
var config float FlagMultiplier; //scale the cost per sec when holding the flag

var config bool bAllowInVehicle;

var string ArtifactID; //for GetArtifact / RPGGetArtifact
var float ActivatedTime;
var config bool bCanBeTossed;

var localized string Description;

var localized string NotEnoughAdrenalineMessage;
var localized string AdrenalineRequiredText;
var localized string UseDelayText;
var localized string NotInVehicleText;

//these are for the HUD
var float NextUseTime; //time when this artifact will be available again

replication
{
     reliable if (Role < ROLE_Authority)
        TossArtifact;
          
     reliable if(Role == ROLE_Authority)
        ClientNotifyUseDelay;
}

static function bool HasActiveArtifact(Pawn Other)
{
     local Inventory Inv;
       
     for(Inv = Other.Inventory; Inv != None; Inv = Inv.Inventory)
     {
        if(RPGArtifact(Inv) != None && RPGArtifact(Inv).bActive)
           return true;
     }
     return false;
}

static function RPGArtifact HasArtifact(Pawn Other)
{
     return RPGArtifact(Other.FindInventoryType(default.class));
}

//Utility function -pd
static function bool IsActiveFor(Pawn Other)
{
     local Inventory Inv;

     if(Other == None)
        return false;
       
     for(Inv = Other.Inventory; Inv != None; Inv = Inv.Inventory)
     {
        if(Inv.class == default.class && RPGArtifact(Inv).bActive)
           return true;
     }
     return false;
}

function StripOut()
{
     local Inventory Inv;

     //Remove me.
     for(Inv = Instigator.Inventory; Inv != None && Inv.Inventory != Self; Inv = Inv.Inventory);
       
     if(Inv != None)
        Inv.Inventory = Self.Inventory;
     else
        Instigator.Inventory = Self.Inventory;
       
     Self.Inventory = None;
}

function SortIn()
{
     local bool bAdded;
     local Inventory Inv, Prev;
     local RPGPlayerReplicationInfo RPRI;
     local int OrderEntry, i;

     RPRI = class'RPGPlayerReplicationInfo'.static.GetFor(Instigator.Controller);
     if(RPRI != None)
     {
        //Re-add me.
        if(Instigator.Inventory != None)
        {
           //Sort the new artifact in so the artifact order is correct.
           OrderEntry = RPRI.FindOrderEntry(default.class);
           if(OrderEntry >= 0)
           {
              for(Inv = Instigator.Inventory; Inv != None; Inv = Inv.Inventory)
              {
                 if(Inv.IsA('RPGArtifact'))
                 {
                    i = RPRI.FindOrderEntry(class<RPGArtifact>(Inv.class));
                    if(i == -1 || i > OrderEntry)
                    {
                       Self.Inventory = Inv;
                       if(Prev != None)
                          Prev.Inventory = Self;
                       else
                          Instigator.Inventory = Self;
                         
                       bAdded = true;
                       break;
                    }
                 }
                 Prev = Inv;
              }
           }
        }
     }

     if(!bAdded)
     {
        //Add to end instead
        for(Inv = Instigator.Inventory; Inv != None && Inv.Inventory != None; Inv = Inv.Inventory);

        if(Inv != None)
           Inv.Inventory = Self;
        else
           Instigator.Inventory = Self;
     }
}

function GiveTo(Pawn Other, optional Pickup Pickup)
{
     local RPGPlayerReplicationInfo RPRI;
     local int i;

     Super.GiveTo(Other, Pickup);
       
     if(NextUseTime == 0.f)
        DoUseDelay();
     else
        ClientNotifyUseDelay(NextUseTime - Level.TimeSeconds);
       
     StripOut();
     SortIn();
       
     //Notify RPRI
     RPRI = class'RPGPlayerReplicationInfo'.static.GetFor(Instigator.Controller);
     if(RPRI != None)
     {
        RPRI.CheckArtifactClass(Self.class);
        for(i = 0; i < RPRI.Abilities.Length; i++)
        {
           if(RPRI.Abilities[i].bAllowed)
              RPRI.Abilities[i].ModifyArtifact(Self);
        }
     }
       
     GotoState('');
}

//New interface to allow damage scaling for artifacts -pd
function AdjustTargetDamage(out int Damage, Actor Victim, Vector HitLocation, out Vector Momentum, class<DamageType> DamageType);
function AdjustPlayerDamage(out int Damage, Pawn InstigatedBy, Vector HitLocation, out Vector Momentum, class<DamageType> DamageType);

function bool HandlePickupQuery(Pickup Item)
{
     if(Item.InventoryType == class)
     {
        if (bCanHaveMultipleCopies)
        {
           NumCopies++;
        }
        else if ( bDisplayableInv )
        {
           if (Item.Inventory != None)
              Charge = Max(Charge, Item.Inventory.Charge);
           else
              Charge = Max(Charge, Item.InventoryType.Default.Charge);
        }
        else
        {
           return false;
        }

        Item.AnnouncePickup(Pawn(Owner));
        Item.SetRespawn();
        return true;
     }
       
     if(Inventory == None)
     {
        return false;
     }

     return Inventory.HandlePickupQuery(Item);
}

//Toss out this artifact
exec function TossArtifact()
{
     local vector X, Y, Z;

     if(bCanBeTossed)
     {
        Instigator.NextItem();
        Velocity = Vector(Instigator.Controller.GetViewRotation());
        Velocity = Velocity * ((Instigator.Velocity Dot Velocity) + 500) + Vect(0,0,200);
        GetAxes(Instigator.Rotation, X, Y, Z);
        DropFrom(Instigator.Location + 0.8 * Instigator.CollisionRadius * X - 0.5 * Instigator.CollisionRadius * Y);
     }
}

function DropFrom(vector StartLocation)
{
     if(bActive)
        GotoState('');

     bActive = false;

     if(bCanBeTossed)
     {
        Super.DropFrom(StartLocation);
     }
     else
     {
        Destroy();
        Instigator.NextItem();
     }
}

function UsedUp()
{
     if(Pawn(Owner) != None)
     {
        Activate();
        Msg(ExpireMessage);
     }
     Owner.PlaySound(DeactivateSound, SLOT_Interface);
}

function Msg(string Message)
{
     if(PlayerController(Instigator.Controller) != None)
        PlayerController(Instigator.Controller).ClientMessage(Message);
}

function bool CanActivate()
{
     local int Countdown;

     if(Vehicle(Instigator) != None && !bAllowInVehicle)
     {
        Msg(NotInVehicleText);
        return false;
     }
       
     if(Level.TimeSeconds < NextUseTime)
     {
        Countdown = int(NextUseTime - Level.TimeSeconds + 1);
        Msg(Repl(UseDelayText, "$1", Countdown @ class'MutTitanRPG'.static.GetSecondsText(Countdown)));
        return false;
     }

     if(MinAdrenaline == 0 && MinActivationTime > 0.0f && Instigator.Controller.Adrenaline < CostPerSec * MinActivationTime)
     {
        Msg(Repl(AdrenalineRequiredText, "$1", class'Util'.static.FormatFloat(CostPerSec * MinActivationTime)));
        return false;
     }
     else if(Instigator.Controller.Adrenaline < Max(CostPerSec, MinAdrenaline))
     {
        Msg(Repl(AdrenalineRequiredText, "$1", string(Max(CostPerSec, MinAdrenaline))));
        return false;
     }
       
     return true;
}

function bool CanDeactivate()
{
     if(MinActivationTime > 0.0f && Level.TimeSeconds < ActivatedTime + MinActivationTime)
        return false;

     return true;
}

function DoUseDelay()
{
     if(UseDelay > 0)
     {
        NextUseTime = Level.TimeSeconds + UseDelay;
        ClientNotifyUseDelay(UseDelay);
     }
}

function Activate()
{
     if(MinActivationTime > 0.f)
     {
        if(bActive && CanDeactivate())
        {
           GotoState('');
           Owner.PlaySound(DeactivateSound, SLOT_Interface);
        }
        else if(!bActive && CanActivate())
        {
           CurrentCostPerSec = 0.f;
           GotoState('Activated');
             
           DoUseDelay();
        }
     }
     else if(CanActivate())
     {
        DoEffect();

        if(CostPerSec > 0)
           Instigator.Controller.Adrenaline = FMax(0, Instigator.Controller.Adrenaline - CostPerSec);
             
        DoUseDelay();
     }
}

//interface for single-hit artifacts
function DoEffect();

state Activated
{
     function BeginState()
     {
        ActivatedTime = Level.TimeSeconds;
        bActive = true;
     }
       
     function EndState()
     {
        RoundAdrenaline();
        bActive = false;
     }

     event Tick(float dt)
     {
        if(Instigator == None || Instigator.Controller == None)
        {
           if(bActive)
           {
              GotoState('');
              bActive = false;
           }
        }
        else
        {
           if(CostPerSec > 0)
           {
              CurrentCostPerSec += float(CostPerSec);
                
              if(Instigator.PlayerReplicationInfo.HasFlag != None)
                 CurrentCostPerSec *= FlagMultiplier;
             
              Instigator.Controller.Adrenaline -= dt * CurrentCostPerSec;
              if(Instigator.Controller.Adrenaline <= 0.0)
              {
                 Instigator.Controller.Adrenaline = 0.0;
                 UsedUp();
              }     
           }
           CurrentCostPerSec = 0.f; //reset
        }
     }
}

//New interface to get extra information which is displayed below the weapon's name -pd
static function string GetArtifactNameExtra()
{
     return default.Description;
}

simulated function ClientNotifyUseDelay(float Delay)
{
     NextUseTime = Level.TimeSeconds + Delay;
}

event Destroyed()
{
     if(Instigator != None && Instigator.SelectedItem == Self)
        Instigator.NextItem();

     Super.Destroyed();
}

//AI
//called after FightEnemy
function BotFightEnemy(Bot Bot);

//called after LoseEnemy returned true (enemy is lost)
function BotLoseEnemy(Bot Bot);

//called OFTEN
function BotWhatNext(Bot Bot);

//prevent rounding issues
function RoundAdrenaline()
{
     if(Instigator != None && Instigator.Controller != None)
        Instigator.Controller.Adrenaline = float(int(Instigator.Controller.Adrenaline + 0.01));
}

defaultproperties
{
       HudColor=(G=255,R=255,A=255)
       FlagMultiplier=1.000000
       bAllowInVehicle=True
       NotEnoughAdrenalineMessage="Не хватает адреналина, чтобы активировать этот артефакт."
       AdrenalineRequiredText="Нужно $1 адреналина для использования."
       UseDelayText="Этот артефакт будет доступен через $1."
       NotInVehicleText="Нельзя использовать сейчас."
       bActivatable=True
       ExpireMessage="Твой адреналин заканчивается."
       bDisplayableInv=True
       bReplicateInstigator=True
       MessageClass=Class'UnrealGame.StringMessagePlus'
}

function BotFightEnemy(Bot Bot)   
{   
         local float Chance;   

         LOG("Function BotFightEnemy called for "$Bot);   

         if(Vehicle(Instigator) != None)
          {
            LOG(Bot$" is in vehicle, exiting function");   
            return;   
          }

         if(!bActive)   
         {   
            LOG("Artefact is not active, continue");    

            if(HasActiveArtifact(Instigator))   
             {
               LOG(Bot$" has other active artefact, exiting function");   
               return;   
             }
                     
            if(WeaponLightningConduction(Bot.Enemy.Weapon) != None)   
             {
               LOG(Bot$" has WLCWeapon, exiting function");   
               return;   
             }             
        
               
            if(   
               Bot.bEnemyIsVisible &&   
               Bot.CombatStyle >= 0 &&   
               Bot.Skill >= 0 &&       
               Bot.Adrenaline >= 50 &&   
               VSize(Bot.Enemy.Location - Instigator.Location) <= TargetRadius)   
            {   
               LOG("Using artefact is possible, calculating chaces");    

               Chance = FMin(0.4, (Bot.StrafingAbility + 1.f) / 4.f);   
               Chance += 0.05 * (Bot.Skill - 3); //max 0.6   
                     
               if(Bot.Enemy.PlayerReplicationInfo != None &&   
                  Bot.Enemy.PlayerReplicationInfo.HasFlag != None)   
                  Chance += 0.15; //max 0.75   
                        
               if(TransLauncher(Bot.Enemy.Weapon) != None)   
                  Chance += 0.1; //max 0.85   
                     
               if(Instigator.HasUDamage())   
                  Chance += 0.75; //max 1.1   
                  
               LOG("Chance = "$Chance);   

               if(FRand() < Chance)   
                {
                  LOG("Chance was larger than some random value, activating artefact");    
                  Activate();   
                }
               else
                  LOG("Chance was smaller than some random value, doing nothing");  
            }   
         }   
         else   
         {   
          LOG("Artefact is active, continue");              
            if(   
               WeaponLightningConduction(Bot.Enemy.Weapon) != None ||   
               VSize(Bot.Enemy.Location - Instigator.Location) > TargetRadius)   
            {   
             LOG(Bot$" has WLCWeapon, deactivating");               
             Activate();   
            }   
         }   
}