//:://////////////////////////////////////////////////
//:: NW_C2_DEFAULT7
/*
  Default OnDeath event handler for NPCs.

  Adjusts killer's alignment if appropriate and
  alerts allies to our death.
*/
//:://////////////////////////////////////////////////
//:: Copyright © 2002 Floodgate Entertainment
//:: Created By: Naomi Novik
//:: Created On: 12/22/2002
//:://////////////////////////////////////////////////

#include "x2_inc_compon"
#include "x0_i0_spawncond"
#include "give_custom_exp"

void main()
{
    int nClass = GetLevelByClass(CLASS_TYPE_COMMONER);
    int nAlign = GetAlignmentGoodEvil(OBJECT_SELF);
    object oKiller = GetLastKiller();
    give_custom_exp(oKiller, OBJECT_SELF, 0);
    // If we're a good/neutral commoner,
    // adjust the killer's alignment evil
    if(nClass > 0 && (nAlign == ALIGNMENT_GOOD || nAlign == ALIGNMENT_NEUTRAL))
    {
        AdjustAlignment(oKiller, ALIGNMENT_EVIL, 5);
    }

    // Call to allies to let them know we're dead
    SpeakString("NW_I_AM_DEAD", TALKVOLUME_SILENT_TALK);

    //Shout Attack my target, only works with the On Spawn In setup
    SpeakString("NW_ATTACK_MY_TARGET", TALKVOLUME_SILENT_TALK);

    // NOTE: the OnDeath user-defined event does not
    // trigger reliably and should probably be removed
    if(GetSpawnInCondition(NW_FLAG_DEATH_EVENT))
    {
        SignalEvent(OBJECT_SELF, EventUserDefined(1007));
    }

//#include "NW_I0_GENERIC"
//#include "_inc_inventory"
//void main(){}
// Remove this line if Scrotok's corpse code is not used.
//#include "_kb_loot_corpse"


//int  Debug = FALSE;          // Set to TRUE enables several debug lines.
                              // Debug info includes party shares, etc.

//int  Double_EXP = TRUE;      // Set to TRUE enables seeing first the PW
                              // experience followed by Bioware experience.
                              // This is useful to compare values.

float Experience_Slider = 0.42;// This is the percentage that can be adjusted.
                              // This value matches the Bioware slider.
float Exp_Level_Cap = 3.0;    // This is the basic CR cap.

int  Boss_Cap_Method = 3;    // These are mode sets for how bosses are handled
                              // Mode 1:  The CR of the boss is modified.
                              //          The exp cap is left at +8 CR.
                              // Mode 2:  The CR of the boss is left alone.
                              //          The exp cap is raised by the mod.
                              // Mode 3:  The CR of the boss is modified.
                              //          The exp cap is raised by the mod.

float Lower_Exponent = 1.50;  // This is the exponent that defines how exp
                              // drops off when the CR is lower than player.

float Higher_Exponent = 1.20;  // This is the exponent that defines how exp
                              // increases whent he CR is higher than player.

float Party_Proximity = 25.0;  // The distance a party member must be to get a
                              // share of the experience.

float Leveling_Exponent = 1.20;// This exponent defines how fast the exponent is
                              // when determining party shares.
                              // The following is the level difference and
                              // how it relates to shares:
                              // 1.10  at  10 levels difference = 1.63 shares
                              // 1.20  at  10 levels difference = 6.19 shares
                              // 1.30  at  10 levels difference = 13.79 shares

float Familiar_Split = 0.01;  // The ratio of shares that a familiar or animal
                              // companion receives.

float Henchman_Split = 0.01;  // The ratio of shares that a henchman or
                              // summoned creature receives.



    //  Absolutely, Positively do not call this function inside another loop
    //  that uses GetNextPC.  This can be used inside GetNextFactionMember().
void SendMessageToParty( object oMember, string sText )
  {

  object oPartyMember = GetFirstPC();
  while( GetIsObjectValid(oPartyMember) )
    {
    if( GetFactionEqual( oPartyMember, oMember ) )
      SendMessageToPC( oPartyMember, sText );
    oPartyMember = GetNextPC();
    }
  }

//  This routine comes from and idea from Tone Eternal.
//  It limits a player from gaining more experience after reaching enough to
//  continue to the next level.  This is not really a bug, but a short-coming
//  of the Bioware code.
//  This function is not used in version 1.4 or higher, but can be installed.


int GetLevel(object oPlayer)
{
    int iXP = GetXP(oPlayer);
    if(iXP < 1000)
        return 1;
    else if(iXP < 3000)
        return 2;
    else if(iXP < 6000)
        return 3;
    else if(iXP < 10000)
        return 4;
    else if(iXP < 15000)
        return 5;
    else if(iXP < 21000)
        return 6;
    else if(iXP < 28000)
        return 7;
    else if(iXP < 36000)
        return 8;
    else if(iXP < 45000)
        return 9;
    else if(iXP < 55000)
        return 10;
    else if(iXP < 66000)
        return 11;
    else if(iXP < 78000)
        return 12;
    else if(iXP < 91000)
        return 13;
    else if(iXP < 105000)
        return 14;
    else if(iXP < 120000)
        return 15;
    else if(iXP < 136000)
        return 16;
    else if(iXP < 153000)
        return 17;
    else if(iXP < 171000)
        return 18;
    else if(iXP < 190000)
        return 19;
    else if(iXP < 210000)
        return 20;
    else if(iXP < 231000)
        return 21;
    else if(iXP < 253000)
        return 22;
    else if(iXP < 276000)
        return 23;
    else if(iXP < 300000)
        return 24;
    else if(iXP < 325000)
        return 25;
    else if(iXP < 351000)
        return 26;
    else if(iXP < 378000)
        return 27;
    else if(iXP < 406000)
        return 28;
    else if(iXP < 435000)
        return 29;
    else if(iXP < 465000)
        return 30;
    else if(iXP < 496000)
        return 31;
    else if(iXP < 528000)
        return 32;
    else if(iXP < 561000)
        return 33;
    else if(iXP < 595000)
        return 34;
    else if(iXP < 630000)
        return 35;
    else if(iXP < 666000)
        return 36;
    else if(iXP < 703000)
        return 37;
    else if(iXP < 741000)
        return 38;
    else if(iXP < 780000)
        return 39;
    else return 40;
}

//  The main routine for giving experience to the player.
//  Created by David Bills.

void give_custom_exp( object oKiller, object oDead, int nCRMod )
{
    // Custom DMG EXP Script (varies slightly on bonuses and penalties)
    // Concept and Original Code By Helznicht
    // Syntax Clean-Up and Area Check Award by Mmealman
    // Major bug rennovation by David Bills.  1-9-03
    // Basic experience for creatures is around Bioware 3%.
    // To adjust this, modify the polynomial equation below.

    if( GetLocalInt( oDead, "AlreadyDyingEXP" ) == 1 )
    {
        DeleteLocalInt(oDead, "AlreadyDyingEXP");
        return;
    }

    // First get all the members of the party
    float LowestLevelMember = 1000.0;
    float HighestLevelMember = -10.0;

    float PartyShares = 0.0;
    float fLevel = 0.0;
    float fCRMod = IntToFloat( nCRMod );

    object oMaster, oHighest, oLowest;

    int bOld;
    int nTotalMembers = 0;
    int flxp1;
    int flxp;

    //check to see if oKiller was summon/familiar.  if so, changes oKiller to summon master.
    oMaster  = GetMaster(oKiller);
    if (GetIsObjectValid(oMaster))
    {
        if (oKiller == GetAssociate(ASSOCIATE_TYPE_FAMILIAR, oMaster)        ||
            oKiller == GetAssociate(ASSOCIATE_TYPE_ANIMALCOMPANION, oMaster) ||
            oKiller == GetAssociate(ASSOCIATE_TYPE_DOMINATED, oMaster)      ||
            oKiller == GetAssociate(ASSOCIATE_TYPE_HENCHMAN, oMaster)        ||
            oKiller == GetAssociate(ASSOCIATE_TYPE_SUMMONED, oMaster)        ||
            oKiller == GetAssociate(ASSOCIATE_TYPE_SUMMONED, oMaster))
                oKiller = oMaster;

    }


    object oPartyMember = GetFirstFactionMember(oKiller, FALSE );
    while( GetIsObjectValid(oPartyMember) && GetIsPC(oKiller))
    {
        if( GetArea(oKiller) == GetArea(oPartyMember)                      &&
            GetCurrentHitPoints( oPartyMember ) > 0                        &&
            GetDistanceBetween( oKiller, oPartyMember ) < Party_Proximity  )
          {
            nTotalMembers++;

            if( GetIsPC( oPartyMember ) )
                fLevel = IntToFloat( GetLevel( oPartyMember ) );
            else
                fLevel = IntToFloat(GetHitDice( oPartyMember ));
            if( LowestLevelMember > fLevel )
            {
                LowestLevelMember = fLevel;
                oLowest = oPartyMember;
            }
            if( HighestLevelMember < fLevel )
            {
                HighestLevelMember = fLevel;
                oHighest = oPartyMember;
            }
        }
        oPartyMember = GetNextFactionMember(oKiller, FALSE);
    }

    // Now we need to test for the Really low level creatures.
    // They need to be scaled as negative level to function properly.
    float fChallenge = GetChallengeRating( oDead );
    if( fChallenge < 1.0 )
        fChallenge =  1.0 - (( 1.0 - fChallenge ) * 5.0);

    // This is the level difference of the dead to the highest
    fLevel = fChallenge - HighestLevelMember;

    if( Boss_Cap_Method == 1 )
    {
        fLevel += fCRMod;
        if( fLevel >= Exp_Level_Cap )
            fLevel = Exp_Level_Cap;
    }
    else if( Boss_Cap_Method == 2 )
    {
        if( fLevel >= Exp_Level_Cap+fCRMod )
            fLevel = Exp_Level_Cap+fCRMod;
    }
    else
    {
        if( fLevel >= Exp_Level_Cap )
            fLevel = Exp_Level_Cap;
        fLevel += fCRMod;
    }


    //Calculate basic value of kill
    float FinalMonValue = 84.0 * HighestLevelMember + 750;

    // This is the exponential function to match the 3e rules.
    // There is some adjustment here to allow for smooth transitions.
    if( fLevel < 0.0 )
        FinalMonValue = FinalMonValue * pow( Lower_Exponent, fLevel );
    else
        FinalMonValue = FinalMonValue * pow( Higher_Exponent, fLevel );
    FinalMonValue = FinalMonValue * Experience_Slider;
    if( FinalMonValue < 0.0 )
        FinalMonValue = 0.0;

    PartyShares = 1.0;

    int nPenalty;
    if( PartyShares > 0.0 )
    {
        //Determine the value of the Split EXP
        // This is based on shares compared to the lowest member to the heighest.
        int SFEint;

        //Distribute EXP to all PCs in the Party based upon shares.
        float fMonst = GetChallengeRating(oDead);
        int HighestLevel = FloatToInt(HighestLevelMember);

        oPartyMember = GetFirstFactionMember(oKiller, TRUE);
        while ( GetIsObjectValid(oPartyMember) )
        {
          int iLeech =  HighestLevel - GetHitDice(oPartyMember);
            if (GetArea(oKiller) == GetArea(oPartyMember)                      &&
                GetCurrentHitPoints( oPartyMember ) > 0                        &&
                GetDistanceBetween( oKiller, oPartyMember ) < Party_Proximity  &&
                iLeech <= 10 )
            {
                SFEint = FloatToInt( FinalMonValue );

                int nCurLevel;
                if(HighestLevel > GetLevel(oPartyMember)+3)
                {
                    nCurLevel = FloatToInt(HighestLevelMember);
                }
                else
                {
                    nCurLevel = GetLevel(oPartyMember);
                }
                if(nCurLevel <= FloatToInt(fMonst)+3)
                {
                    if(GetLevel(oPartyMember) <= 5)
                        SFEint *= 2;

                    if(SFEint > 500)
                        SFEint = 500;

                    GiveXPToCreature(oPartyMember, SFEint);

                    int iCR = FloatToInt(fMonst);
                    int iGP = d20(1);
                    int iGPT = iGP + iCR*15;
                    if (iGPT < 1)
                    {
                        GiveGoldToCreature(oPartyMember, 1);
                    }
                    else
                    {
                        if(GetLevel(oPartyMember) < 5)
                            iGPT *= 2;
                        GiveGoldToCreature(oPartyMember, iGPT);
                    }
                }
                else
                {
                    GiveGoldToCreature(oPartyMember, 1);
                    GiveXPToCreature(oPartyMember, SFEint);
                }
            }
            oPartyMember = GetNextFactionMember(oKiller, TRUE);
        }
    }
}

give_custom_exp(oKiller, OBJECT_SELF, 0);

int StartingConditional()
{

    if(Random(2) >= 1)
        return TRUE;

    return FALSE;
}

int StartingConditional()
{
    //смотрим, сколько у нас веток в диалоге
    //напрямую это сделать нельзя, так что удобно будет руками (опция advanced - variables) запихать количество веток в локальную переменную на неписе
    int nBranchCount = GetLocalInt(OBJECT_SELF, "nBranchCount");
    //задаём ветку
    SetLocalInt(OBJECT_SELF, "nCurrentBranchNumber", Random(nBranchCount) + 1);
    //выходим из ветки
    return FALSE;
}

//номер ветки
const int BRANCH_NUMBER = 1;

int StartingConditional()
{
    //проверяем, совпадает ли выпавший выше рандом с номером ветки
    return GetLocalInt(OBJECT_SELF, "nCurrentBranchNumber") == BRANCH_NUMBER;
}

//give_custom_exp(oKiller, OBJECT_SELF, 0);

//:://////////////////////////////////////////////
//::  SLOT: OnDeath — смерть существа
//:://////////////////////////////////////////////
void main()
{ExecuteScript("nw_c2_default7", OBJECT_SELF);}

void main()
{
object oPC = GetFirstPC();
int iTH = GetTimeHour();
int iRest = GetLocalInt(oPC, "REST");

//////////////////////////////    FINISH    ///////////////////////////////////
if (GetLastRestEventType() == REST_EVENTTYPE_REST_FINISHED)
  {
   iTH = iTH+1;
   SetTime(iTH,0,0,0);
   SendMessageToPC(oPC, "Вы отдыхали 1 час.");
   SetCommandable(TRUE, oPC); // разблокировать очередь
   FakeRestore(oPC); // Если нужно удалить вредные эффекты
   // ВРЕМЯ БЛОКИРОВКИ
   SetLocalInt(GetFirstPC(),"REST",1);
   DelayCommand(600.0, SetLocalInt(GetFirstPC(),"REST",0));
  }
}

SetLocalInt(oPC,"REST",1);
   DelayCommand(600.0, SetLocalInt(oPC,"REST",0));