//:://////////////////////////////////////////////
//:: OnUserDefaine  am_cud_methan
//:: Copyright © 2005 WRG!
//:://////////////////////////////////////////////
/*
    Стандартный UserDefaine скрипт
*/
//:://////////////////////////////////////////////
//:: Created By: Aiwan
//:: Created On: 09.07.2005
//:://///////////////////////////////////////////
//#include "am_inc_battle"
//#include "am_inc_common"
//#include "am_inc_cutscene"

int GetIsAssociate(object oMaster, object oAssociate)
{
    object oMaster = GetMaster(oAssociate);
    if(oMaster != OBJECT_INVALID)
      {
      return TRUE;
      }
        return FALSE;
}

void ClearAllPersonalReputation(object oMaster, object oSource=OBJECT_SELF, int iClearAllActions = FALSE)
{
    object oAnimal = GetAssociate(ASSOCIATE_TYPE_ANIMALCOMPANION, oMaster);
    object oDominated = GetAssociate(ASSOCIATE_TYPE_DOMINATED, oMaster);
    object oFamiliar = GetAssociate(ASSOCIATE_TYPE_FAMILIAR, oMaster);
    object oSummoned = GetAssociate(ASSOCIATE_TYPE_SUMMONED, oMaster);

    if(iClearAllActions = TRUE)
    AssignCommand(oMaster,ClearAllActions(TRUE));
    ClearPersonalReputation(oMaster, oSource);

    if(oAnimal != OBJECT_INVALID)
    {
      if(iClearAllActions = TRUE)
      AssignCommand(oAnimal,ClearAllActions(TRUE));
      ClearPersonalReputation(oAnimal, oSource);
    }
    if(oDominated != OBJECT_INVALID)
    {
      if(iClearAllActions = TRUE)
      AssignCommand(oDominated,ClearAllActions(TRUE));
      ClearPersonalReputation(oDominated, oSource);
    }
    if(oFamiliar != OBJECT_INVALID)
    {
      if(iClearAllActions = TRUE)
      AssignCommand(oFamiliar,ClearAllActions(TRUE));
      ClearPersonalReputation(oFamiliar, oSource);
    }
    if(oSummoned != OBJECT_INVALID)
    {
      if(iClearAllActions = TRUE)
      AssignCommand(oSummoned,ClearAllActions(TRUE));
      ClearPersonalReputation(oSummoned, oSource);
    }
    int i = 1;
    object oHenchman = GetHenchman(oMaster, i);
    while(oHenchman != OBJECT_INVALID)
    {
      if(iClearAllActions = TRUE)
      AssignCommand(oHenchman,ClearAllActions(TRUE));
      ClearPersonalReputation(oHenchman, oSource);
      i++;
      oHenchman = GetHenchman(oMaster, i);
    }
}

void FreezeCompanion(object oPlayers, int bVanish=FALSE)
{
    effect eAssociate = EffectCutsceneParalyze();
    effect eInv = EffectVisualEffect(VFX_DUR_CUTSCENE_INVISIBILITY);
    int i = 1;
    object oHench = GetHenchman(oPlayers, i);
    while(oHench != OBJECT_INVALID)
    {
        AssignCommand(oHench,
        ApplyEffectToObject(DURATION_TYPE_PERMANENT, eAssociate, oHench));
        if(bVanish==TRUE){
        AssignCommand(oHench,
            ApplyEffectToObject(DURATION_TYPE_PERMANENT, eInv, oHench));}
        i++;
        oHench = GetHenchman(oPlayers, i);
    }
    object oCompanion = GetAssociate(ASSOCIATE_TYPE_ANIMALCOMPANION, oPlayers);
    if (oCompanion != OBJECT_INVALID)
    {
      AssignCommand(oCompanion,
      ApplyEffectToObject(DURATION_TYPE_PERMANENT, eAssociate, oCompanion));
      if(bVanish==TRUE){
      AssignCommand(oCompanion,
            ApplyEffectToObject(DURATION_TYPE_PERMANENT, eInv, oCompanion));}
    }
    object oFamiliar = GetAssociate(ASSOCIATE_TYPE_FAMILIAR, oPlayers);
    if (oFamiliar != OBJECT_INVALID)
    {
      AssignCommand(oFamiliar,
      ApplyEffectToObject(DURATION_TYPE_PERMANENT, eAssociate, oFamiliar));
      if(bVanish==TRUE){
            AssignCommand(oFamiliar,
            ApplyEffectToObject(DURATION_TYPE_PERMANENT, eInv, oFamiliar));}
    }
    object oSummon = GetAssociate(ASSOCIATE_TYPE_SUMMONED, oPlayers);
    if (oSummon != OBJECT_INVALID)
    {
      AssignCommand(oSummon,
      ApplyEffectToObject(DURATION_TYPE_PERMANENT, eAssociate, oSummon));
      if(bVanish==TRUE){
            AssignCommand(oSummon,
            ApplyEffectToObject(DURATION_TYPE_PERMANENT, eInv, oSummon));}
    }
    object oDominated = GetAssociate(ASSOCIATE_TYPE_DOMINATED, oPlayers);
    if (oDominated != OBJECT_INVALID)
    {
      AssignCommand(oDominated,
      ApplyEffectToObject(DURATION_TYPE_PERMANENT, eAssociate, oDominated));
      if(bVanish==TRUE){
            AssignCommand(oDominated,
            ApplyEffectToObject(DURATION_TYPE_PERMANENT, eInv, oDominated));}
    }
}

void RemoveingBadEffectForCut(object oCreature)
{
        effect eBad = GetFirstEffect(oCreature);
        while(GetIsEffectValid(eBad))
        {
            if (GetEffectType(eBad) == EFFECT_TYPE_ABILITY_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_AC_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_ATTACK_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_DAMAGE_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_DAMAGE_IMMUNITY_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_SAVING_THROW_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_SPELL_RESISTANCE_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_SKILL_DECREASE ||
                GetEffectType(eBad) == EFFECT_TYPE_BLINDNESS ||
                GetEffectType(eBad) == EFFECT_TYPE_DEAF ||
                GetEffectType(eBad) == EFFECT_TYPE_PARALYZE ||
                GetEffectType(eBad) == EFFECT_TYPE_POISON ||
                GetEffectType(eBad) == EFFECT_TYPE_SLOW ||
                GetEffectType(eBad) == EFFECT_TYPE_BLINDNESS ||
                GetEffectType(eBad) == EFFECT_TYPE_NEGATIVELEVEL)
                {
                    RemoveEffect(oCreature, eBad);
                }
            eBad = GetNextEffect(oCreature);
        }
        //Fire cast spell at event for the specified target
        SignalEvent(oCreature, EventSpellCastAt(OBJECT_SELF, SPELL_RESTORATION, FALSE));
}

void CutsceneOn(object oPlayers)
{
  if(GetCutsceneMode(oPlayers) == FALSE)
  {
    RemoveingBadEffectForCut(oPlayers);
    SetLocalInt(oPlayers, "CUTSCENEMOD", TRUE);
    SetCutsceneMode(oPlayers, TRUE);
  }
}

void ChangeEnemyToNetral(object oPlayer, object oNetral)
{
    object oArea  = GetArea(oPlayer);
    object oEnemy = GetFirstObjectInArea(oArea);
    object oAnimal = GetAssociate(ASSOCIATE_TYPE_ANIMALCOMPANION, oPlayer);
    object oDominated = GetAssociate(ASSOCIATE_TYPE_DOMINATED, oPlayer);
    object oFamiliar = GetAssociate(ASSOCIATE_TYPE_FAMILIAR, oPlayer);
    object oSummoned = GetAssociate(ASSOCIATE_TYPE_SUMMONED, oPlayer);
    effect eEffect = EffectVisualEffect(VFX_IMP_UNSUMMON);
    while (GetIsObjectValid(oEnemy))
    {
      if (GetIsEnemy(oPlayer,oEnemy))
      {

/*
//------------------------------------------------------------------------------
// Если пойдет что-то не так. Будут жалобы игроков, то помощников НПС буду удалять...
//------------------------------------------------------------------------------
                  int iNum = 1;
                  while(iNum < 6)
                  {
                  object oAssociate = GetAssociate(iNum, oEnemy);
                  if(GetIsObjectValid(oAssociate))
                  {
                    ApplyEffectToObject(DURATION_TYPE_INSTANT, eEffect, oAssociate);
                    DestroyObject(oAssociate, 0.5);
                  }
                  iNum++;
                  }
*/
//----------------------- Обработка помощников игрока -------------------------//
                if(oAnimal != OBJECT_INVALID) {
                AssignCommand(oAnimal,ClearAllActions(TRUE));
                ClearPersonalReputation(oAnimal,oEnemy);}
                if(oDominated != OBJECT_INVALID){
                AssignCommand(oDominated,ClearAllActions(TRUE));
                ClearPersonalReputation(oDominated,oEnemy);}
                if(oFamiliar != OBJECT_INVALID){
                AssignCommand(oFamiliar,ClearAllActions(TRUE));
                ClearPersonalReputation(oFamiliar,oEnemy);}
                if(oSummoned != OBJECT_INVALID){
                AssignCommand(oSummoned,ClearAllActions(TRUE));
                ClearPersonalReputation(oSummoned,oEnemy);}
                int i = 1;
                object oHench = GetHenchman(oPlayer, i);
                  while(oHench != OBJECT_INVALID)
                    {
                    AssignCommand(oHench,ClearAllActions(TRUE));
                    ClearPersonalReputation(oHench,oEnemy);
                    i++;
                    oHench = GetHenchman(oPlayer, i);
                    }
                AssignCommand(oEnemy,ClearAllActions(TRUE));
                ClearPersonalReputation(oPlayer,oEnemy);
                ChangeFaction(oEnemy,oNetral);
      }
      oEnemy = GetNextObjectInArea(oArea);
    }
}

void main()
{
  int nEvent = GetUserDefinedEventNumber();
  object oPC = GetFirstPC();
  object oSelf = OBJECT_SELF;
  object oAlishan = GetObjectByTag("AM_HEN_ALISHAN");
  object oNeytral = GetObjectByTag("GLOBAL_TRUE_NEUTRAL");

  if (GetIsDead(OBJECT_SELF)==TRUE) return; // Если он помер, то пусть молчит
  if (GetArea(OBJECT_SELF)!=GetArea(GetFirstPC())) return;
  if (GetImmortal(OBJECT_SELF) == FALSE) return;

  if(!GetLocalInt(oSelf, "METHAN_BATTLE_PC")) return;
//=========================== HEARTBEAT EVENT ==================================
  if (nEvent == EVENT_HEARTBEAT) // Сигнал поступает User Defined Event 1001
  {
    int iCurHP = GetCurrentHitPoints(oSelf); // Количество поинтов максимум о Нпс
    if(!GetLocalInt(oSelf, "HIT_POINTS"))
    {
      if (iCurHP <= 15)
      {
        CutsceneOn(oPC);
        FreezeCompanion(oPC);
        SetLocalInt(oSelf, "HIT_POINTS", TRUE);
        SetLocalInt(oSelf, "REPEAT", TRUE);

        AssignCommand(oPC, ClearAllActions(TRUE));
        AssignCommand(oSelf, ClearAllActions(TRUE));
        AssignCommand(oAlishan, ClearAllActions(TRUE));
        ChangeEnemyToNetral(oPC, oNeytral);
        ClearAllPersonalReputation(oPC, oSelf, TRUE);
        if(GetIsAssociate(oPC, oAlishan))
        ClearAllPersonalReputation(oAlishan, oSelf, TRUE);
        AssignCommand(oSelf, ActionDoCommand(SetFacingPoint(GetPosition(oPC))));
        DelayCommand(1.0, AssignCommand(oSelf, PlayVoiceChat(VOICE_CHAT_DEATH)));
        DelayCommand(1.01, AssignCommand(oSelf, SpeakString("Пощади, "+GetName(oPC)+"!!!")));
        DelayCommand(1.4, AssignCommand(oSelf, PlayAnimation(ANIMATION_LOOPING_MEDITATE, 1.0, 4.0)));
        DelayCommand(1.5, RemoveingBadEffectForCut(oPC));
        DelayCommand(2.0, RemoveingBadEffectForCut(oSelf));
        DelayCommand(3.0, AssignCommand(oPC, PlayAnimation(ANIMATION_LOOPING_TALK_FORCEFUL, 1.0, 4.0)));
        DelayCommand(3.5, AssignCommand(oPC, PlayVoiceChat(VOICE_CHAT_TALKTOME)));
        DelayCommand(3.51, AssignCommand(oPC, SpeakString("Вставай! Будь мужчиной!")));
      }
    }
    else
        {
          if (GetIsInCombat(oPC) || GetIsInCombat(oSelf) || IsInConversation(oPC))
          {
            if(GetIsAssociate(oPC, oAlishan) && GetIsInCombat(oAlishan))
            {
                AssignCommand(oAlishan, ClearAllActions(TRUE));
                ClearAllPersonalReputation(oAlishan, oSelf, TRUE);
                ChangeEnemyToNetral(oAlishan, oNeytral);
            }
            ChangeEnemyToNetral(oPC, oNeytral);
            // РС или НПС занят, что то мешает им поговорить.
            return;
          }
          else if (GetLocalInt(oSelf, "REPEAT")==TRUE)
            {
              object oItem1 = GetItemPossessedBy(oSelf, "AM_ITM_SHIELS012");
              AssignCommand(oSelf, ClearAllActions());
              AssignCommand(oSelf, ActionForceMoveToObject(oPC, FALSE, 1.0, 15.0));
              AssignCommand(oSelf, ActionStartConversation(oPC));
              AssignCommand(oSelf, ActionDoCommand(SetLocalInt(oSelf, "METHAN_BATTLE_PC", FALSE)));
              AssignCommand(oSelf, ActionDoCommand(SetLocalInt(oSelf,"REPEAT", FALSE)));
              AssignCommand(oSelf, ActionDoCommand(SetLocalInt(oSelf,"HIT_POINTS", FALSE)));
              // Если Метхан не смог подойти и поговорить, напомним об этом
          }
      }
  }
//------------------------------------------------------------------------------
}

//------------------------------------------------------------------------------
//  Добавляем на хертбит Нпс.
//------------------------------------------------------------------------------
    object oSelf = OBJECT_SELF;
    object oPC = GetFirstPC(); // Это самое простое. Можно узнать по демагу или ближайший крич
    int iCurHP = GetCurrentHitPoints(oSelf); // Количество поинтов максимум о Нпс
    int iMaxHP = GetMaxHitPoints(oSelf); // Сколько в данный момент
    if(!GetLocalInt(oSelf, "STOP"))
    {
      if (iCurHP < iMaxHP/4) // Четверть нр от общего или меньше
      {
        // Если это враг то меняем ему фракцию на комманера. Если нет, то убери эту строку
        ChangeToStandardFaction(oSelf, STANDARD_FACTION_COMMONER);
        SetLocalInt(oSelf, "STOP", TRUE);
        AssignCommand(oPC, ClearAllActions(TRUE));
        AssignCommand(oSelf, ClearAllActions(TRUE));
        ClearPersonalReputation(oPC, oSelf);
        AssignCommand(oSelf, PlayAnimation(ANIMATION_LOOPING_TALK_PLEADING, 1.0, 5.0));
        DelayCommand(0.3, SetCommandable(FALSE, oPC));
        DelayCommand(1.5, AssignCommand(oSelf, SpeakString("Дядя, простите, я больше так не буду!")));
        /*
        Тут описываешь важнецкие клятвы в верности, слезные истории про трудное дество...
        */
        DelayCommand(5.0, AssignCommand(oSelf, ActionMoveToObject(oPC)));
        DelayCommand(5.4, AssignCommand(oSelf, ActionDoCommand(SetCommandable(TRUE, oPC))));
        DelayCommand(5.6, AssignCommand(oSelf, ActionStartConversation(oPC)));
      }

    }

//------------------------------------------------------------------------------

void main()
{
    object oPC = GetEnteringObject();
    // Если хочешь лежа, то замени на ANIMATION_LOOPING_DEAD_BACK
    AssignCommand(oPC, ActionPlayAnimation(ANIMATION_LOOPING_SIT_CROSS, 1.0, 99999.0));
}

if (iCurPCHP < 2) // Если НПС выиграл

SetLocalLocation(oNPC, "Return_LOC", GetLocation(oNPC));

location Loc = GetLocalLocation(oNPC, "Return_LOC");

object oFaction = GetObjectByTag("temp_enemy");
//Тэг НПСа с нужной нам фракцией (обязательно должен быть в области)

object oFaction = GetNearestObjectByTag("temp_enemy",);
// Get the nth Object nearest to oTarget that has sTag as its tag.
// * Return value on error: OBJECT_INVALID
object GetNearestObjectByTag(string sTag, object oTarget=OBJECT_SELF, int nNth=1)
// string sTag – это тэг объекта
// object oTarget=OBJECT_SELF – это объект относительно которого мы определяем наш ближайший с тэгом sTag. По умолчанию он равен OBJECT_SELF, т.е. с кого мы читаем скрипт.
// int nNth=1 – это порядковый номер, используется при подсчете объектов с одинаковы тэгом, а распределяются номера, в зависимости он расстояния от объекта отчета… Объект отчета, по определению не может быть ближайшим объектом!

//:: СЛОТ: OnDamaged
void main()
{
object oSelf = OBJECT_SELF;
int Uron = GetLocalInt(oSelf, "SUM_XP");
int iMaxHit = GetMaxHitPoints(oSelf);
int iCurHit = GetCurrentHitPoints(oSelf);
int iX = iMaxHit - (iCurHit+Uron);

SetLocalInt(oSelf, "SUM_XP", GetLocalInt(oSelf, "SUM_XP") + iX); // Урон
}

void main()
{
  object oPC = GetEnteringObject(); // Кто вошел на триггер
  if (!GetIsPC(oPC) || GetLocalInt(OBJECT_SELF, "TRIGGER") || GetIsInCombat(oPC))
        return; // Если не игрок, или уже наступал, или идет бой то возврат
  SetLocalInt(OBJECT_SELF, "TRIGGER", TRUE);
  ActionDoCommand(DoSinglePlayerAutoSave()); // Автосейв, на случай пожарный
  ActionDoCommand(StartNewModule("имя_модуля")); // НО БЕЗ РАСШИРЕНИЯ! *.mod
}

if(GetIsInCombat(oNPC))
    {
    AssignCommand(oNPC, SurrenderToEnemies());
    AssignCommand(oNPC, ClearAllActions(TRUE));
    }

float fFas =GetLocalFloat(oNPC, "FacingPoint");
ActionWait(fNPCKnockdownTime + 2.0);
AssignCommand(oNPC,_ActionMoveToLocation(Loc));
AssignCommand(oNPC, ActionDoCommand(DelayCommand(0.3, SetFacing(fFas))));

//::////////////////////////////////////////////////////////////////////////////
//:: Name: sl_on_used
//:: Place: OnUsed Placeble
//::////////////////////////////////////////////////////////////////////////////
/*
ОПИСАНИЕ:
Скрипт дуэли между ПС и НПС. На обоих до начала боя вешается бессмертие.
Дуэль проигрывает тот, у кого остался 1 хитпоинт.
Проигравший на время вырубается и, опционально, у него выбрасываются
оружие и деньги.
УСТАНОВКА:
Скрипт sl_on_used поставить на любое действие, которое должно активиоровать дуэль
Скрипт sl_OnCombatRoundEnd поставить на OnCombatRoundEnd НПСа, с которым будет дуэль
Создать фракцию temp_enemy, нейтральную ко всем, кроме игрока, к нему враждебна
Создать существо с этой фракцией в закрытой локе
Удостовериться в том, что НПС с которым будет дуэль - не единственный в своей фракции,
если единственный, то создать существо с его фракцией в закрытой локе
(опционально) Настроить НПС с приведенными ниже параметрами
ПАРАМЕТРЫ НПС:
Установите на НПС локальные переменные числового типа,
если хотите отключить следующие возможности скрипта
(Название переменной/Значение/Описание)
WinCountOFF/1/НЕ Считает количество побед НПС над ПС
DefeatCountOFF/1/НЕ Считает количество поражений НПС от ПС
WeaponDropOFF/1/НПС при поражение НЕ выбрасывает свое оружие
MoneyDropOFF/1/НПС при поражение НЕ выбрасывает свои деньги
GetPlayerWeaponMoneyOFF/1/НПС при победе НЕ забирает оружие и деньги ПС
HealOFF/1/НПС НЕ лечится после боя
OwnWeaponPickUpOFF/1/Если ПС после победы не взял оружие и/или золото НПС,
                                          то НПС когда оклемается, подберет его
WeaponHideOFF/1/Если НПС перед боем стоял без оружия,
                                      то после боя он НЕ убирает его в инвентарь
GoHomeOFF/1/НПС после боя НЕ возврашается на то место,
                                                    где он был перед началом боя
*/
//::////////////////////////////////////////////////////////////////////////////
//:: Created By: Slam
//:: Created On: 14.05.07
//:: Debugging help: gennady
//::////////////////////////////////////////////////////////////////////////////

void main()
{
    object oPC = GetFirstPC();
    object oNPC = GetNearestObjectByTag("npc_guard");
    object oFaction = GetObjectByTag("temp_enemy");
    // МЕНЯЕМ ФРАКЦИЮ НПС НА РОДНУЮ ////////////////////////////////////////////
    object oFactionMember = GetNextFactionMember(oNPC, FALSE);
    int i;
    for (i = 0; i < 5; i++)
    {
        if (oFactionMember != oNPC)
        {
            SetLocalObject(oNPC, "FactionMember", oFactionMember);
        break;
        }
        oFactionMember = GetNextFactionMember(oFactionMember, FALSE);
    }
    ////////////////////////////////////////////////////////////////////////////
    // ВОЗВРАЩАЕМ НПС НА МЕСТО /////////////////////////////////////////////////
    if (GetLocalInt(oNPC, "GoHomeOFF") == 0)
    {
        SetLocalLocation(oNPC, "Return_Loc", GetLocation(oNPC));
        SetLocalFloat(oNPC, "FacingPoint", GetFacing(oNPC));
    }
    ////////////////////////////////////////////////////////////////////////////
    SetLocalInt(oNPC, "bImmortalAttack", 1);
    // ОПРЕДЕЛЯЕМ, ДЕРЖИТ ЛИ НПС ОРУЖИЕ В РУКАХ ДО НАЧАЛА БОЯ //////////////////
    if (GetLocalInt(oNPC, "WeaponHideOFF") == 0)
    {
        object oRHand=GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oNPC);
        object oLHand=GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oNPC);
        if(oRHand != OBJECT_INVALID || oLHand != OBJECT_INVALID)
        {
            SetLocalInt(oNPC, "bIsArmed", 1);
        }
    }
    ////////////////////////////////////////////////////////////////////////////
    AssignCommand(oNPC, ClearAllActions());
    AssignCommand(oNPC, ActionEquipMostDamagingMelee());
    ChangeFaction(oNPC, oFaction);
    SetImmortal(oNPC, TRUE);
    SetImmortal(oPC, TRUE);
    AssignCommand(oNPC, ActionDoCommand(ActionAttack(oPC)));
}

//::////////////////////////////////////////////////////////////////////////////
//:: Name: sl_OnCombatRoundEnd
//:: Place: OnCombatRoundEnd Creature
//::////////////////////////////////////////////////////////////////////////////
/*
*/
//::////////////////////////////////////////////////////////////////////////////
//:: Created By: Slam
//:: Created On: 14.05.07
//:: Debugging help: gennady
//::////////////////////////////////////////////////////////////////////////////

#include "x0_i0_position"

void DefeatCount(object oNPC);
void General(object oPC, object oNPC);
void ChangeFactionToParrent(object oNPC);
void WeaponDrop(object oNPC);
void MoneyDrop(object oNPC);
void WinCount(object oNPC);
void Heal(object oNPC);
void GetPlayerWeaponMoney(object oNPC, object oPC);
void GoHome(object oNPC);
void WeaponHide(object oNPC);
void Heal(object oNPC);
void OwnWeaponPickUp(object oNPC);
void DoIt(object oNPC);

void main()
{
    ExecuteScript("nw_c2_default3", OBJECT_SELF);

    object oNPC = OBJECT_SELF;
    if (GetLocalInt(oNPC, "bImmortalAttack") == 1)
    {
        object oPC = GetFirstPC();
        int nCurPCHP = GetCurrentHitPoints(oPC);
        int nCurNPCHP = GetCurrentHitPoints(oNPC);
        // Если ПС выиграл
        if (nCurNPCHP < 2)
        {
            // УВЕЛИЧИВАЕМ ЛОКАЛКУ, КОТОРАЯ СЧИТАЕТ ПОРАЖАЕНИЯ НПС НА 1, см. void DefeatCount(object oNPC)
            if (GetLocalInt(oNPC, "DefeatCountOFF") == 0)
                DefeatCount(oNPC);
            effect eKnockdown = EffectKnockdown();
            string sPCwinString = "Получил!";
            float fNPCKnockdownTime = 10.0;
            float fNPCParentFacingPoint = GetLocalFloat(oNPC, "FacingPoint");
            // ОБЩАЯ ПРОЦЕДУРА ДЛЯ НПС, НЕ ЗАВИСИМО, ВЫИГРАЛ ОН ИЛИ ПРОИГРАЛ, см. void General(object oPC, object oNPC)
            General(oPC, oNPC);
            // НПС ВЫКИДЫВАЕТ СВОЕ ОРУЖИЕ ПЕРЕД СОБОЙ, см. void WeaponDrop(object oNPC)
            if (GetLocalInt(oNPC, "WeaponDropOFF") == 0)
                WeaponDrop(oNPC);
            // НПС ВЫКИДЫВАЕТ СВОИ ДЕНЬГИ ПЕРЕД СОБОЙ, см. void MoneyDrop(object oNPC)
            if (GetLocalInt(oNPC, "MoneyDropOFF") == 0)
                MoneyDrop(oNPC);
            AssignCommand(oNPC, ActionDoCommand(ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eKnockdown, oNPC, fNPCKnockdownTime)));
            AssignCommand(oPC, ActionSpeakString(sPCwinString));
            // ВЫПОЛНЯЕТСЯ, КОГДА НПС ПРОИГРАЛ, см. void DoIt(object oNPC) /////
            DelayCommand(fNPCKnockdownTime + 0.3, DoIt(oNPC));
        }
        // Если НПС выиграл
        if (nCurPCHP < 2)
        {
            // УВЕЛИЧИВАЕМ ЛОКАЛКУ, КОТОРАЯ СЧИТАЕТ ПОБЕДЫ НПС НА 1, см. void WinCount(object oNPC)
            if (GetLocalInt(oNPC, "WinCountOFF") == 0)
                WinCount(oNPC);
            string sNPCwinString = "Получил!";
            float fPCKnockdownTime = 10.0;
            // ОБЩАЯ ПРОЦЕДУРА ДЛЯ НПС, НЕ ЗАВИСИМО, ВЫИГРАЛ ОН ИЛИ ПРОИГРАЛ, см. void General(object oPC, object oNPC)
            General(oPC, oNPC);
            ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectKnockdown(), oPC, fPCKnockdownTime);
            AssignCommand(oNPC, SpeakString(sNPCwinString));
            AssignCommand(oNPC, ActionWait(3.0));
            // НПС ПЬЕТ ИЗ БУТЫЛКИ И ЛЕЧИТСЯ, см. void Heal(object oNPC)
            if (GetLocalInt(oNPC, "HealOFF") == 0)
                Heal(oNPC);
            // НПС ЗАБИРАЕТ ЗОЛОТО И ОРУЖИЕ ИГРОКА, ЕСЛИ ОНИ ЕСТЬ, см. void GetPlayerWeaponMoney(object oNPC, object oPC)
            if (GetLocalInt(oNPC, "GetPlayerWeaponMoneyOFF") == 0)
                GetPlayerWeaponMoney(oNPC, oPC);
            // ВОЗВРАЩАЕМ НПС НА МЕСТО, см. void GoHome(object oNPC) ///////////
            if (GetLocalInt(oNPC, "GoHomeOFF") == 0)
                GoHome(oNPC);
            // ЕСЛИ НПС ДО НАПАДЕНИЯ БЫЛ БЕЗ ОРУЖИЯ, УБИРАЕМ ОРУЖИЕ В ИНВЕНТАРЬ, см. void WeaponHide(object oNPC)
            if (GetLocalInt(oNPC, "WeaponHideOFF") == 0)
                WeaponHide(oNPC);
        }
    }
    else return;
}


// ОБЩАЯ ПРОЦЕДУРА ДЛЯ НПС, НЕ ЗАВИСИМО, ВЫИГРАЛ ОН ИЛИ ПРОИГРАЛ ///////////////
void General(object oPC, object oNPC)
{
    DeleteLocalInt(oNPC, "bImmortalAttack");
    SetImmortal(oNPC, FALSE);
    SetImmortal(oPC, FALSE);
    // МЕНЯЕМ ФРАКЦИЮ НПС НА РОДНУЮ, см. void ChangeFactionToParrent(object oNPC)
    ChangeFactionToParrent(oNPC);
    ClearPersonalReputation(oPC, oNPC);
    AssignCommand(oNPC, ClearAllActions(TRUE));
    AssignCommand(oPC, ClearAllActions(TRUE));
}
////////////////////////////////////////////////////////////////////////////////

// МЕНЯЕМ ФРАКЦИЮ НПС НА РОДНУЮ ////////////////////////////////////////////////
void ChangeFactionToParrent(object oNPC)
{
    if (GetIsObjectValid(GetLocalObject(oNPC, "FactionMember")))
    {
    object oFactionMember = GetLocalObject(oNPC, "FactionMember");
    ChangeFaction(oNPC, oFactionMember);
    }
    else
    ChangeToStandardFaction(oNPC, STANDARD_FACTION_COMMONER);
    DeleteLocalObject(oNPC, "FactionMember");
}
////////////////////////////////////////////////////////////////////////////////

// ВОЗВРАЩАЕМ НПС НА МЕСТО /////////////////////////////////////////////////////
void GoHome(object oNPC)
{
    float fNPCParentFacingPoint = GetLocalFloat(oNPC, "FacingPoint");
    location lNPCParentLoc = GetLocalLocation(oNPC, "Return_Loc");
    AssignCommand(oNPC, ActionMoveToLocation(lNPCParentLoc));
    AssignCommand(oNPC, ActionDoCommand(DelayCommand(0.3, SetFacing(fNPCParentFacingPoint))));
    DeleteLocalLocation(oNPC, "Return_Loc");
    DeleteLocalFloat(oNPC, "FacingPoint");
}
////////////////////////////////////////////////////////////////////////////////

// ЕСЛИ НПС ДО НАПАДЕНИЯ БЫЛ БЕЗ ОРУЖИЯ, УБИРАЕМ ОРУЖИЕ В ИНВЕНТАРЬ
void WeaponHide(object oNPC)
{
    if (GetLocalInt(oNPC, "bIsArmed") == 0)
    {
        object oNPCRightHand = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oNPC);
        object oNPCLeftHand = GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oNPC);
        AssignCommand(oNPC, ActionDoCommand(DelayCommand(1.0, ActionUnequipItem(oNPCRightHand))));
        AssignCommand(oNPC, ActionDoCommand(DelayCommand(1.5, ActionUnequipItem(oNPCLeftHand))));
    }
    DeleteLocalInt(oNPC, "bIsArmed");
}
////////////////////////////////////////////////////////////////////////////////

// НПС ЗАБИРАЕТ ЗОЛОТО И ОРУЖИЕ ИГРОКА, ЕСЛИ ОНИ ЕСТЬ //////////////////////////
void GetPlayerWeaponMoney(object oNPC, object oPC)
{
    int nPCGold = GetGold(oPC);
    object oPCWeaponTag = GetLastWeaponUsed(oPC);
    if ((nPCGold != 0) && (GetIsObjectValid(oPCWeaponTag)))
    { // Есть золото, есть оружие
        string sNPCmoneyweaponString = "И деньги и оружие. Богатый сегодня улов";
        location lPCMoneyLoc = GenerateNewLocationFromLocation(GetLocation(oPC), 1.0, GetLeftDirection(GetFacing(oPC)), 90.0);
        location lPCWeaponLoc = GenerateNewLocationFromLocation(GetLocation(oPC), 0.5, GetRightDirection(GetFacing(oPC)), 90.0);
        object oPCGold = CreateObject(OBJECT_TYPE_ITEM, "nw_it_gold001", lPCMoneyLoc);
        string sPCWeaponResRef = GetResRef(oPCWeaponTag);
        object oPCWeapon = CreateObject(OBJECT_TYPE_ITEM, sPCWeaponResRef, lPCWeaponLoc);
        TakeGoldFromCreature(nPCGold, oPC, TRUE);
        SetItemStackSize(oPCGold, nPCGold);
        AssignCommand(oNPC, ActionPickUpItem(oPCGold));
        DestroyObject(oPCWeaponTag);
        AssignCommand(oNPC, ActionPickUpItem(oPCWeapon));
        AssignCommand(oNPC, ActionSpeakString(sNPCmoneyweaponString));
    }
    else if ((nPCGold != 0) && !(GetIsObjectValid(oPCWeaponTag)))
    { // Есть золото, нет оружия
        location lPCMoneyLoc = GenerateNewLocationFromLocation(GetLocation(oPC), 1.0, GetLeftDirection(GetFacing(oPC)), 90.0);
        string sNPCmoneynoweaponString = "И зачем тебе деньги, ты даже оружия не можешь купить";
        object oPCGold = CreateObject(OBJECT_TYPE_ITEM, "nw_it_gold001", lPCMoneyLoc);
        TakeGoldFromCreature(nPCGold, oPC, TRUE);
        SetItemStackSize(oPCGold, nPCGold);
        AssignCommand(oNPC, ActionPickUpItem(oPCGold));
        AssignCommand(oNPC, ActionSpeakString(sNPCmoneynoweaponString));
    }
    else if ((nPCGold == 0) && (GetIsObjectValid(oPCWeaponTag)))
    { // Нет золота, есть оружие
        location lPCWeaponLoc = GenerateNewLocationFromLocation(GetLocation(oPC), 0.5, GetRightDirection(GetFacing(oPC)), 90.0);
        string sNPCnomoneyweaponString = "Хорошее у тебя было оружие, жаль, что еще денег нет";
        string sPCWeaponResRef = GetResRef(oPCWeaponTag);
        object oPCWeapon = CreateObject(
        OBJECT_TYPE_ITEM, sPCWeaponResRef, lPCWeaponLoc);
        DestroyObject(oPCWeaponTag);
        AssignCommand(oNPC, ActionPickUpItem(oPCWeapon));
        AssignCommand(oNPC, ActionSpeakString(
        sNPCnomoneyweaponString));
    }
    else
    { // Нет золота, нет оружия
        string sNPCnomoneynoweaponString = "Ни денег, ни оружия, и зачем ты на меня полез?!";
        AssignCommand(oNPC, ActionMoveToObject(oPC));
        AssignCommand(oNPC, ActionSpeakString(
        sNPCnomoneynoweaponString));
    }
    AssignCommand(oNPC, ActionWait(3.0));
}
////////////////////////////////////////////////////////////////////////////////

// НПС ПЬЕТ ИЗ БУТЫЛКИ И ЛЕЧИТСЯ ///////////////////////////////////////////////
void Heal(object oNPC)
{
    int nMaxNPCHP = GetMaxHitPoints(oNPC);
    AssignCommand(oNPC, ActionPlayAnimation(ANIMATION_FIREFORGET_DRINK));
    ApplyEffectToObject(DURATION_TYPE_PERMANENT, EffectHeal(nMaxNPCHP), oNPC);
}
////////////////////////////////////////////////////////////////////////////////

// УВЕЛИЧИВАЕМ ЛОКАЛКУ, КОТОРАЯ СЧИТАЕТ ПОБЕДЫ НПС НА 1 ////////////////////////
void WinCount(object oNPC)
{
    int nWinCount = GetLocalInt(oNPC, "WinCount");
    SetLocalInt(oNPC, "WinCount", nWinCount + 1);
}
////////////////////////////////////////////////////////////////////////////////

// НПС ВЫКИДЫВАЕТ СВОИ ДЕНЬГИ ПЕРЕД СОБОЙ //////////////////////////////////////
void MoneyDrop(object oNPC)
{
    int nNPCGold = GetGold(oNPC);
    if (nNPCGold !=0)
    {
        location lNPCGoldLoc = GenerateNewLocationFromLocation(GetLocation(oNPC), 0.5, GetLeftDirection(GetFacing(oNPC)), 0.0);
        object oNPCGold = CreateObject(OBJECT_TYPE_ITEM, "nw_it_gold001", lNPCGoldLoc);
        TakeGoldFromCreature(nNPCGold, oNPC, TRUE);
        SetItemStackSize(oNPCGold, nNPCGold);
    }
}
////////////////////////////////////////////////////////////////////////////////

// НПС ВЫКИДЫВАЕТ СВОЕ ОРУЖИЕ ПЕРЕД СОБОЙ //////////////////////////////////////
void WeaponDrop(object oNPC)
{
    object oNPCWeapon = GetLastWeaponUsed(oNPC);
    if (GetIsObjectValid(oNPCWeapon))
    {
        SetLocalString(oNPC, "NPCWeaponTag", GetTag(oNPCWeapon));
        location lNPCWeaponLoc = GenerateNewLocationFromLocation(GetLocation(oNPC), 1.0, GetRightDirection(GetFacing(oNPC)), 90.0);
        string sNPCItemResRef = GetResRef(oNPCWeapon);
        DestroyObject(oNPCWeapon);
        CreateObject(OBJECT_TYPE_ITEM, sNPCItemResRef, lNPCWeaponLoc);
    }
}
////////////////////////////////////////////////////////////////////////////////

// УВЕЛИЧИВАЕМ ЛОКАЛКУ, КОТОРАЯ СЧИТАЕТ ПОРАЖАЕНИЯ НПС НА 1 ////////////////////
void DefeatCount(object oNPC)
{
    int nDefeatCount = GetLocalInt(oNPC, "DefeatCount");
    SetLocalInt(oNPC, "DefeatCount", nDefeatCount + 1);
}
////////////////////////////////////////////////////////////////////////////////

// НПС СОБИРАЕТ СВОЕ ОРУЖИЕ, ЕСЛИ ИГРОК НЕ ПОДНЯЛ ЕГО //////////////////////////
void OwnWeaponPickUp(object oNPC)
{
    object oNPCWeapon = GetNearestObjectByTag(GetLocalString(oNPC, "NPCWeaponTag"));
    if (GetIsObjectValid(oNPCWeapon))
    {
        AssignCommand(oNPC, ActionPickUpItem(oNPCWeapon));
    }
    object oNPCGold = GetNearestObjectByTag("NW_IT_GOLD001");
    if (GetIsObjectValid(oNPCGold))
    {
        AssignCommand(oNPC, ActionPickUpItem(oNPCGold));
    }
}
////////////////////////////////////////////////////////////////////////////////

// ВЫПОЛНЯЕТСЯ, КОГДА НПС ПРОИГРАЛ, сделанна из-за своей криворукости при работе с DelayCommand
void DoIt(object oNPC)
{
    string sNPCdefeatString = "Ммм... Моя голова";
    AssignCommand(oNPC, ActionSpeakString(sNPCdefeatString));
    AssignCommand(oNPC, ActionWait(3.0));
    // НПС ПЬЕТ ИЗ БУТЫЛКИ И ЛЕЧИТСЯ, см. void Heal(object oNPC) ///////////////
    if (GetLocalInt(oNPC, "HealOFF") == 0)
        Heal(oNPC);
    // НПС СОБИРАЕТ СВОЕ ОРУЖИЕ, ЕСЛИ ИГРОК НЕ ПОДНЯЛ ЕГО, см. void OwnWeaponPickUp(object oNPC)
    if (GetLocalInt(oNPC, "OwnWeaponPickUpOFF") == 0)
        OwnWeaponPickUp(oNPC);
    DeleteLocalString(oNPC, "NPCWeaponTag");
    // ВОЗВРАЩАЕМ НПС НА МЕСТО, см. void GoHome(object oNPC) ///////////////////
    if (GetLocalInt(oNPC, "GoHomeOFF") == 0)
        GoHome(oNPC);
    // ЕСЛИ НПС ДО НАПАДЕНИЯ БЫЛ БЕЗ ОРУЖИЯ, УБИРАЕМ ОРУЖИЕ В ИНВЕНТАРЬ, см. void WeaponHide(object oNPC)
    if (GetLocalInt(oNPC, "WeaponHideOFF") == 0)
        WeaponHide(oNPC);
}

//::///////////////////////////////////////////////
//:: Name: sl_KnockDown
//:: Place: Ever
//:://////////////////////////////////////////////
/*
Описание:
НПС вырубает ПС с анимацией одного удара
*/
//:://////////////////////////////////////////////
//:: Created By: Slam
//:: Created On: 22.05.07
//:://////////////////////////////////////////////

#include "sc_inc_debug"
void main()
{
    SetLocalInt(GetModule(), "DebugMode", 4);
    SetLocalInt(GetModule(), "DebugLogFile", 1);

    object oPC = GetFirstPC();
    object oNPC = OBJECT_SELF;

    SetCommandable(FALSE,oPC);
    SetImmortal(oPC, TRUE);
    SetImmortal(oNPC, TRUE);
    AssignCommand(oNPC, ClearAllActions());
// Записываем в локалку текущую фракцию НПС ////////////////////////////////////
    object oFactionMember = GetNextFactionMember(oNPC, FALSE);
    int i;
    for (i = 0; i < 5; i++)
    {
        if (oFactionMember != oNPC)
        {
            SetLocalObject(oNPC, "FactionMember", oFactionMember);
            break;
        }
        oFactionMember = GetNextFactionMember(oFactionMember, FALSE);
    }
////////////////////////////////////////////////////////////////////////////////

// ОПРЕДЕЛЯЕМ, ДЕРЖИТ ЛИ НПС ОРУЖИЕ В РУКАХ ДО НАЧАЛА БОЯ //////////////////////
    object oRHand = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oNPC);
    object oLHand = GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oNPC);
    if(oRHand != OBJECT_INVALID || oLHand != OBJECT_INVALID)
    {
        SetLocalInt(oNPC, "bIsArmed", 1);
    }
////////////////////////////////////////////////////////////////////////////////

// Ударяем, а потом вырубаем ПС ////////////////////////////////////////////////
    effect eKnockdown = EffectKnockdown();
    float fNPCKnockdownTime = 10.0;
    AssignCommand(oNPC, ActionUseFeat(FEAT_KNOCKDOWN, oPC));
    DelayCommand(0.5, ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eKnockdown, oPC, fNPCKnockdownTime));
////////////////////////////////////////////////////////////////////////////////

    DelayCommand(1.5, FadeToBlack(oPC));

// Востанавливаем фракцию НПС //////////////////////////////////////////////////
    if (GetIsObjectValid(GetLocalObject(oNPC, "FactionMember")))
    {
        object oFactionMember = GetLocalObject(oNPC, "FactionMember");
        DelayCommand(0.6, ChangeFaction(oNPC, oFactionMember));
        DelayCommand(0.7, DeleteLocalObject(oNPC, "FactionMember"));
    }
    else
        DelayCommand(0.6, ChangeToStandardFaction(oNPC, STANDARD_FACTION_COMMONER));
    DelayCommand(0.8, ClearPersonalReputation(oPC, oNPC));
////////////////////////////////////////////////////////////////////////////////

    AssignCommand(oNPC, DelayCommand(0.9, ClearAllActions(TRUE)));

// Лечим НПС и ПС //////////////////////////////////////////////////////////////
    int nMaxNPCHP = GetMaxHitPoints(oNPC);
    int nMaxPCHP = GetMaxHitPoints(oPC);
    DelayCommand(3.0, ApplyEffectToObject(DURATION_TYPE_PERMANENT, EffectHeal(nMaxNPCHP), oNPC));
    DelayCommand(3.0, ApplyEffectToObject(DURATION_TYPE_PERMANENT, EffectHeal(nMaxPCHP), oPC));
////////////////////////////////////////////////////////////////////////////////

// ЕСЛИ НПС ДО НАПАДЕНИЯ БЫЛ БЕЗ ОРУЖИЯ, УБИРАЕМ ОРУЖИЕ В ИНВЕНТАРЬ ////////////
    if (GetLocalInt(oNPC, "bIsArmed") == 0)
    {
        AssignCommand(oNPC, DelayCommand(
            9.0, ActionUnequipItem(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oNPC))));
        AssignCommand(oNPC, DelayCommand(
            9.1, ActionUnequipItem(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oNPC))));
    }
    DeleteLocalInt(oNPC, "bIsArmed");
////////////////////////////////////////////////////////////////////////////////

    DelayCommand(fNPCKnockdownTime, FadeFromBlack(oPC));
    DelayCommand(fNPCKnockdownTime, SetCommandable(TRUE, oPC));
}

//:://////////////////////////////////////////////
//:: ActionTaken  am_at_attack
//:: Copyright © 2005 WRG!
//:://////////////////////////////////////////////
/*
    Стандартный скрипт аттаки игроком НПС.
    НПС переводится в НЕЙТРАЛЬНУЮ фракцию.
*/
//:://////////////////////////////////////////////
//:: Created By: Aiwan
//:: Created On: 24.05.2005
//:://///////////////////////////////////////////
#include "nw_i0_generic"
void main()
{
    object oPC = GetPCSpeaker();
    object oNeutral = GetObjectByTag("GLOBAL_TRUE_NEUTRAL");
    object oSelf = OBJECT_SELF;
    AssignCommand(oSelf, ClearAllActions());
    ChangeFaction(oSelf, oNeutral);
    SetIsTemporaryEnemy(oPC, oSelf);
    AssignCommand(oSelf, DetermineCombatRound(oPC));
    DelayCommand(1.0, AssignCommand(oSelf, ActionAttack(oPC)));
}

//:://////////////////////////////////////////////
//:: ActionTaken  am_at_attack_pc
//:: Copyright © 2005 WRG!
//:://////////////////////////////////////////////
/*
    Скрипт аттаки игроком НПС в диалоге.
    НПС не переводится в НЕЙТРАЛЬНУЮ фракцию.
    Все НПС с одинаковой фракцией в радиусе
    50 метров будут нападать на РС.
*/
//:://////////////////////////////////////////////
//:: Created By: Aiwan
//:: Created On: 20.12.2005
//:://///////////////////////////////////////////
#include "nw_i0_generic"

void main()
{
    object oPC = GetPCSpeaker();
    object oSelf = OBJECT_SELF;
    object oNpc = GetFirstObjectInShape(SHAPE_CUBE, 50.0, GetLocation(OBJECT_SELF));
    float n;
    string sSpeak;

    while (GetIsObjectValid(oNpc)) // пока такой объект существует...
    {
        if (GetFactionEqual(oSelf, oNpc)) // если фракциa сходна с исходным
        {
            n = IntToFloat(Random(50))/10.0;
            // врем задержки делное на 10. то есть от 0.0 до 5.0 секунды
            AssignCommand(oNpc, ClearAllActions()); // очистить действиa
            int iRand = Random(15);
              switch (iRand)
              {
                    case 0:
                    {
                        sSpeak = "Смерть тебе!"; break;
                    }
                    case 3:
                    {
                        sSpeak = "А ну! Стоять!"; break;
                    }
                    case 5:
                    {
                        sSpeak = "Стой!!!"; break;
                    }
                    case 8:
                    {
                        sSpeak = "Все сюда!"; break;
                    }
                    case 11:
                    {
                        sSpeak = "Тревога!!!"; break;
                    }
                    case 13:
                    {
                        sSpeak = "Я тебя убью!"; break;
                    }
              }
            DelayCommand(n - 0.2, AssignCommand(oNpc, SpeakString(sSpeak)));
            SetIsTemporaryEnemy(oPC, oNpc);
            AssignCommand(oNpc, DetermineCombatRound(oPC));
            DelayCommand(n, AssignCommand(oNpc, ActionAttack(oPC)));
        }
        oNpc = GetNextObjectInShape(SHAPE_CUBE, 50.0, GetLocation(OBJECT_SELF));
        // Берем следующего НПС в кубе с такой же гранью 50 метров
    }
    AssignCommand(oSelf, ClearAllActions());
    SetIsTemporaryEnemy(oPC, oNpc);
    AssignCommand(oSelf, DetermineCombatRound(oPC));
    DelayCommand(1.0, AssignCommand(oSelf, ActionAttack(oPC)));
}

#include "lib"

void main()
{
object oPC = GetEnteringObject();
object oRoba = GetObjectByTag("itm_roba");
  {
  clearPCInventory();
  clearPCSlot(INVENTORY_SLOT_ARMS);
  clearPCSlot(INVENTORY_SLOT_ARROWS);
  clearPCSlot(INVENTORY_SLOT_BELT);
  clearPCSlot(INVENTORY_SLOT_BOLTS);
  clearPCSlot(INVENTORY_SLOT_BOOTS);
  clearPCSlot(INVENTORY_SLOT_BULLETS);
  clearPCSlot(INVENTORY_SLOT_CHEST);
  clearPCSlot(INVENTORY_SLOT_CLOAK);
  clearPCSlot(INVENTORY_SLOT_HEAD);
  clearPCSlot(INVENTORY_SLOT_LEFTHAND);
  clearPCSlot(INVENTORY_SLOT_LEFTRING);
  clearPCSlot(INVENTORY_SLOT_NECK);
  clearPCSlot(INVENTORY_SLOT_RIGHTHAND);
  clearPCSlot(INVENTORY_SLOT_RIGHTRING);
  ActionGiveItem(oRoba, oPC);
  AssignCommand(oPC, ActionWait(1.0));
  AssignCommand(oPC, ActionStartConversation(oPC, "start_dialog"));
  }
}

/*

*/

//int W_DEBUG = TRUE;
int W_DEBUG = FALSE;

object getPC();
void print(string str);

int W_EV_BEAT = 1001;
int W_EV_CONV = 1004;

int W_EV_CEND = 201;
int W_EV_SPWN = 202;

// -----------------------------------------------

void clearPCInventory() {
  object obj= getPC();
  object item= GetFirstItemInInventory(obj);
  while(item!=OBJECT_INVALID) {
    DestroyObject(item);
    item= GetNextItemInInventory(obj);
  }
}

void clearPCSlot(int slot) {
  object obj= getPC();
  object item= GetItemInSlot(slot, obj);
  if(item!=OBJECT_INVALID)
    DestroyObject(item);
}
int hasItemEquipped(string tag, object obj) {
  object item= GetItemPossessedBy(obj, tag);
  return item!=OBJECT_INVALID && (
    GetItemInSlot(INVENTORY_SLOT_ARMS    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_ARROWS  , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_BELT    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_BOLTS    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_BOOTS    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_BULLETS  , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_CHEST    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_CLOAK    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_HEAD    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_LEFTHAND , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_LEFTRING , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_NECK    , obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, obj) == item ||
    GetItemInSlot(INVENTORY_SLOT_RIGHTRING, obj) == item
  );
}

void RemoveXPFromParty(int nXP, object oPC, int bAllParty=TRUE)
{

if (!bAllParty)
  {
  nXP=(GetXP(oPC)-nXP)>=0 ? GetXP(oPC)-nXP : 0;
  SetXP(oPC, nXP);
  }
else
  {
  object oMember=GetFirstFactionMember(oPC, TRUE);

  while (GetIsObjectValid(oMember))
      {
      nXP=(GetXP(oMember)-nXP)>=0 ? GetXP(oMember)-nXP : 0;
      SetXP(oMember, nXP);
      oMember=GetNextFactionMember(oPC, TRUE);
      }
  }
}
void ApplyPenalty(object oDead)
{
    int nXP = GetXP(oDead);
    int nPenalty = 250 * GetHitDice(oDead);
    int nHD = GetHitDice(oDead);
    // * You can not lose a level with this respawning
    int nMin = ((nHD * (nHD - 1)) / 2) * 1000;

    int nNewXP = nXP - nPenalty;
    if (nNewXP < nMin)
      nNewXP = nMin;
    SetXP(oDead, nNewXP);
    int nGoldToTake = FloatToInt(0.20 * GetGold(oDead));
    // * a cap of 10 000gp taken from you
    if (nGoldToTake > 50000)
    {
        nGoldToTake = 50000;
    }
    AssignCommand(oDead, TakeGoldFromCreature(nGoldToTake, oDead, TRUE));
    DelayCommand(4.0, FloatingTextStrRefOnCreature(58299, oDead, FALSE));
    DelayCommand(4.8, FloatingTextStrRefOnCreature(58300, oDead, FALSE));

}
#include "nw_i0_plot"
/*  Script generated by
Lilac Soul's NWN Script Generator, v. 2.0

For download info, please visit:
http://nwvault.ign.com/View.php?view=Other...4683&id=625    */

//Goes OnPlayerRespawn of the module properties
void main()
{

object oPC = GetLastRespawnButtonPresser();
object oDead = oPC;
string sArea = GetTag(GetArea(oPC));
if (!GetIsPC(oPC)) return;

ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectResurrection(),oPC);

ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectHeal(GetMaxHitPoints(oPC)), oPC);

RemoveEffects(oPC);

object oTarget;
oTarget = oPC;

//Visual effects can't be applied to waypoints, so if it is a WP
//apply to the WP's location instead

int nInt;
nInt = GetObjectType(oTarget);

if((sArea == "AREA1") ||
  ( sArea == "AREA2") == FALSE )
{

  //Для Всех
  location lHALFELFTarget;
  oTarget = GetWaypointByTag("TN_SPAWN");
  lHALFELFTarget = GetLocation(oTarget);
  if (nInt != OBJECT_TYPE_WAYPOINT) ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_TIME_STOP), oTarget);
  else ApplyEffectAtLocation(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_TIME_STOP), GetLocation(oTarget));

  if (GetAreaFromLocation(lHALFELFTarget)==OBJECT_INVALID) return;

  AssignCommand(oPC, ClearAllActions());

  AssignCommand(oPC, ActionJumpToLocation(lHALFELFTarget));



ApplyPenalty(oDead);


}

}

if(sArea != "AREA1" || sArea != "AREA2")

if(sArea == "AREA1" || sArea == "AREA2")
{
  return;
}
else
       {
         // ТУТ ТВОЙ СКРИПТ
        }

if(sArea != "AREA1" && sArea != "AREA2")

#include "X0_I0_SPELLS"
#include "x2_inc_spellhook"


void DoArmageddon()
{
vector vSelf = GetPosition(OBJECT_SELF);
vector v1 = Vector(vSelf.x+10.0f, vSelf.y+10.0f, 0.0f);
vector v2 = Vector(vSelf.x-10.0f, vSelf.y+10.0f, 0.0f);
vector v3 = Vector(vSelf.x+10.0f, vSelf.y-10.0f, 0.0f);
vector v4 = Vector(vSelf.x-10.0f, vSelf.y-10.0f, 0.0f);
//вокруг чара 4 точки создаются, куда эффекты налагаются
object oArea = GetArea(OBJECT_SELF);

location Loc1 = Location(oArea, v1, GetFacing(OBJECT_SELF));
location Loc2 = Location(oArea, v2, GetFacing(OBJECT_SELF));
location Loc3 = Location(oArea, v3, GetFacing(OBJECT_SELF));
location Loc4 = Location(oArea, v4, GetFacing(OBJECT_SELF));


ApplyEffectAtLocation(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_METEOR_SWARM), Loc1);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_METEOR_SWARM), Loc2);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_METEOR_SWARM), Loc3);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_METEOR_SWARM), Loc4);

}

void main()
{
int nDam1, nDam2;
effect eDam, eDam2;
DoArmageddon();
object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, 20.0f, GetLocation(OBJECT_SELF), OBJECT_TYPE_CREATURE || OBJECT_TYPE_PLACEABLE);
while (GetIsObjectValid(oTarget))
    {
    if (spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF) && oTarget != OBJECT_SELF)
        {
            nDam1 = d10(20);
            nDam2 = d10(5);
            eDam = EffectDamage(nDam1, DAMAGE_TYPE_FIRE);
            eDam2 = EffectDamage(nDam2, DAMAGE_TYPE_MAGICAL);
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget);
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam2, oTarget);
        }
        oTarget = GetNextObjectInShape(SHAPE_SPHERE, 20.0f, GetLocation(OBJECT_SELF), OBJECT_TYPE_CREATURE || OBJECT_TYPE_PLACEABLE);
    }


}