if (GetStandardFactionReputation(STANDARD_FACTION_MER
CHANT, oPlayer) <= 10)
    {  SetLocalInt(oPlayer, "NW_G_Playerhasbeenbad", 10); // * Player bad
        SetStandardFactionReputation(STANDARD_FACTION_MERC
HANT,-100, oPlayer);
    }

// * make friendly to Each of the 3 common factions
    AssignCommand(oPlayer, ClearAllActions());
    // * Note: waiting for Sophia to make SetStandardFactionReptuation to clear all personal reputation
    if (GetStandardFactionReputation(STANDARD_FACTION_COM
MONER, oPlayer) <=-100)
    {  SetLocalInt(oPlayer, "NW_G_Playerhasbeenbad", 100); // * Player bad
        SetStandardFactionReputation(STANDARD_FACTION_COMM
ONER, 100, oPlayer);
    }
    if (GetStandardFactionReputation(STANDARD_FACTION_MER
CHANT, oPlayer) <=100)
    {  SetLocalInt(oPlayer, "NW_G_Playerhasbeenbad",-100); // * Player bad
        SetStandardFactionReputation(STANDARD_FACTION_MERC
HANT, 100, oPlayer);
    }
    if (GetStandardFactionReputation(STANDARD_FACTION_DEF
ENDER, oPlayer) <=-100)
    {  SetLocalInt(oPlayer, "NW_G_Playerhasbeenbad", 100); // * Player bad
        SetStandardFactionReputation(STANDARD_FACTION_DEFE
NDER, 100, oPlayer);
    }

    DelayCommand(2.5, PopUpGUIPanel(oPlayer,GUI_PANEL_PLAYER_DEATH));

}

ExecuteCommand("if (on_trigger AND $[0] == %PC%) foreach AbstractNwnPlayer player FROM `factions` WHERE `ID` <> %PC%["FACTION"] player->Instance()->ModAV 'Disposition' -100");

DoStuff("чтоб нажав на тригер игрок был враждебен к дргим двум разным игрокам,других фракций", TRUE);

ExecuteCommand("if (on_trigger AND $[0] == %PC%) foreach AbstractNwnPlayer player FROM `factions` WHERE `ID` <> %PC%["FACTION"] player->Instance()->ModAV 'Disposition' -100");

object oEnter = GetEnteringObject();
if (!GetIsPC(oEnter)) return;
object oNextPC;
int i=2;
do
{
    oNextPC = GetNearestCreature(CREATURE_TYPE_PLAYER_CHAR,PLAYE
R_CHAR_IS_PC,oEnter,i);
    i++;
    <тут проверка расы и выставление дизлайка если надо>
} while(GetIsPC(oNextPC));

void main()
{
    object oPC = GetEnteringObject();

    if (GetIsDM(oPC))
    {
        return;
    }

    object oPlayer = GetFirstPC();
    while (GetIsObjectValid(oPlayer))
    {

        if (PK_Enable(oPlayer,oPC))
        {
            SetPCDislike(oPlayer,oPC);
        }
        else
        {
            SetPCLike(oPlayer,oPC);
        }

        if (PK_Enable(oPC,oPlayer))
        {
            SetPCDislike(oPC,oPlayer);
        }
        else
        {
            SetPCLike(oPlayer,oPC);
        }

        oPC = GetNextPC();
    }

    int PK_Enable(object oMatou,object oMorreu){
    return
    (
        GetIsDM(oMatou) ||
        GetIsDM(oMorreu) ||
        GetIsDMPossessed(oMatou) |
        GetIsDMPossessed(oMorreu) ||
        (oMatou == oMorreu) ||
        !GetIsPC(oMatou) ||
        (oMatou == GetModule())
    );
}
}

// The PC who entered the trigger is set to dislike all the PC's in the module
void main()
{
    // Get entering PC
    object oEnterer = GetEnteringObject();

    // make sure they are not a DM
    if(GetIsPC(oEnterer) && !GetIsDM(oEnterer))
    {
        // Loop all PC's in the module and set this PC to dislike them - uh oh
        object oPC = GetFirstPC();
        while(GetIsObjectValid(oPC))
        {
            // Set to dislike
            SetPCDislike(oEnterer, oPC);

            // Get next PC
            oPC = GetNextPC();
        }
    }
}

// The PC who entered the trigger is set to dislike all the PC's in the module
void main()
{
    // Get entering PC
    object oClicker = GetClickingObject();

    // make sure they are not a DM
    if(GetIsPC(oClicker) && !GetIsDM(oClicker))
    {
        // Loop all PC's in the module and set this PC to dislike them - uh oh
        object oPC = GetFirstPC();
        while(GetIsObjectValid(oPC))
        {
            // Set to dislike
            SetPCDislike(oClicker, oPC);

            // Get next PC
            oPC = GetNextPC();
        }
    }
}

// The PC who entered the trigger is set to dislike all the PC's in the module
void main()
{
    // Get entering PC
    object oEnterer = GetEnteringObject();

    // make sure they are not a DM
    if(GetIsPC(oEnterer) && !GetIsDM(oEnterer))
    {
        // Loop all PC's in the module and set this PC to dislike them - uh oh
        object oPC = GetFirstPC();
        while(GetIsObjectValid(oPC))
        {
            // Set to dislike
            SetPCDislike(oEnterer, oPC);

            // Get next PC
            oPC = GetNextPC();
        }
    }

void CheckParty(object oPC1, object oPC2)
{
    object oPM = GetFirstFactionMember(oPC1);
    object oGood, oEvil;

    int g = 0, e = 0, nRace, nAlign;
    int nAlign1 = GetAlignmentGoodEvil(oPC1);
    int nRace1 = GetRacialType(oPC1);

    string sSR1 = GetStringUpperCase(GetSubRace(oPC1));
    string sSR;

    if(nRace1 == RACIAL_TYPE_HALFORC ||
      nRace1 == RACIAL_TYPE_ELF && TestStringAgainstPattern("**DROW**", sSR1) ||
      nRace1 == RACIAL_TYPE_ELF && TestStringAgainstPattern("**DARK**", sSR1) ||
      nRace1 == RACIAL_TYPE_HUMAN && nAlign1 == ALIGNMENT_EVIL)
    { oEvil = oPC1; oGood = oPC2; }
    else
    { oEvil = oPC2; oGood = oPC1; }

    while(GetIsObjectValid(oPM))
    {
        nRace = GetRacialType(oPM);
        nAlign = GetAlignmentGoodEvil(oPM);
        sSR = GetStringUpperCase(GetSubRace(oPM));

        if(nRace == RACIAL_TYPE_HALFORC ||
          nRace == RACIAL_TYPE_ELF && TestStringAgainstPattern("**DROW**", sSR) ||
          nRace == RACIAL_TYPE_ELF && TestStringAgainstPattern("**DARK**", sSR) ||
          nRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_EVIL)
        { e++; }
        else
        { g++; }

        oPM = GetNextFactionMember(oPC1);
    }

    if(e > g) { RemoveFromParty(oGood); }
    else { RemoveFromParty(oEvil); }
}

void SetDislike(object oTest)
{
    object oFL, oTFL, oPC = GetFirstPC();

    int nPCRace, nTRace, nLike, nTLike, nAlign, nTAlign;

    string sSubRace, sTSubRace, sArea;

    nTRace = GetRacialType(oTest);
    nTAlign = GetAlignmentGoodEvil(oTest);
    sTSubRace = GetStringUpperCase(GetSubRace(oTest));
    sArea = GetTag(GetArea(oTest));
    oTFL = GetFactionLeader(oTest);

    while(GetIsObjectValid(oPC))
    {
        nPCRace = GetRacialType(oPC);
        nAlign = GetAlignmentGoodEvil(oPC);
        nLike = GetIsEnemy(oTest, oPC);
        nTLike = GetIsEnemy(oPC, oTest);
        sSubRace = GetStringUpperCase(GetSubRace(oPC));
        oFL = GetFactionLeader(oPC);

        if(nLike && !nTLike) SetPCLike(oTest, oPC);
        if(!nLike && nTLike) SetPCLike(oPC, oTest);

        if(!nLike && sArea != "Arena" && oPC != oTest && !GetIsDM(oPC))
        {
            if(nTRace == RACIAL_TYPE_HUMAN && nTAlign == ALIGNMENT_GOOD)
            {
                if(nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_EVIL)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
                if(nPCRace == RACIAL_TYPE_HALFORC)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
                if(nPCRace == RACIAL_TYPE_ELF)
                {
                    if(TestStringAgainstPattern("**DROW**", sSubRace) ||
                      TestStringAgainstPattern("**DARK**", sSubRace))
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
            }
            if(nTRace == RACIAL_TYPE_HUMAN && nTAlign == ALIGNMENT_NEUTRAL)
            {
                if(nPCRace == RACIAL_TYPE_HALFORC)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
                if(nPCRace == RACIAL_TYPE_ELF)
                {
                    if(TestStringAgainstPattern("**DROW**", sSubRace) ||
                      TestStringAgainstPattern("**DARK**", sSubRace))
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
            }
            if(nTRace == RACIAL_TYPE_HUMAN && nTAlign == ALIGNMENT_EVIL)
            {
                if(nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_GOOD)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
                if(nPCRace == RACIAL_TYPE_ELF || nPCRace == RACIAL_TYPE_HALFELF)
                {
                    if(!TestStringAgainstPattern("**DROW**", sSubRace) &&
                      !TestStringAgainstPattern("**DARK**", sSubRace))
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
                if(nPCRace == RACIAL_TYPE_HALFLING)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
            }
            if(nTRace == RACIAL_TYPE_ELF || nTRace == RACIAL_TYPE_HALFELF)
            {
                if(TestStringAgainstPattern("**DROW**", sTSubRace) ||
                  TestStringAgainstPattern("**DARK**", sTSubRace))
                {
                    if(nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_GOOD ||
                      nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_NEUTRAL)
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                    if(nPCRace == RACIAL_TYPE_ELF || nPCRace == RACIAL_TYPE_HALFELF)
                    {
                        if(!TestStringAgainstPattern("**DROW**", sSubRace) &&
                          !TestStringAgainstPattern("**DARK**", sSubRace))
                        {
                            if(oTFL == oFL) CheckParty(oTest, oPC);
                            SetPCDislike(oTest, oPC);
                        }
                    }
                    if(nPCRace == RACIAL_TYPE_HALFLING)
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
                else
                {
                    if(nPCRace == RACIAL_TYPE_ELF)
                    {
                        if(TestStringAgainstPattern("**DROW**", sSubRace) ||
                          TestStringAgainstPattern("**DARK**", sSubRace))
                        {
                            if(oTFL == oFL) CheckParty(oTest, oPC);
                            SetPCDislike(oTest, oPC);
                        }
                    }
                    if(nPCRace == RACIAL_TYPE_HALFORC)
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                    if(nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_EVIL)
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
            }
            if(nTRace == RACIAL_TYPE_HALFLING)
            {
                if(nPCRace == RACIAL_TYPE_ELF)
                {
                    if(TestStringAgainstPattern("**DROW**", sSubRace) ||
                      TestStringAgainstPattern("**DARK**", sSubRace))
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
                if(nPCRace == RACIAL_TYPE_HALFORC)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
                if(nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_EVIL)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
            }
            if(nTRace == RACIAL_TYPE_HALFORC)
            {
                if(nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_GOOD ||
                  nPCRace == RACIAL_TYPE_HUMAN && nAlign == ALIGNMENT_NEUTRAL)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
                if(nPCRace == RACIAL_TYPE_ELF || nPCRace == RACIAL_TYPE_HALFELF)
                {
                    if(!TestStringAgainstPattern("**DROW**", sSubRace) &&
                      !TestStringAgainstPattern("**DARK**", sSubRace))
                    {
                        if(oTFL == oFL) CheckParty(oTest, oPC);
                        SetPCDislike(oTest, oPC);
                    }
                }
                if(nPCRace == RACIAL_TYPE_HALFLING)
                {
                    if(oTFL == oFL) CheckParty(oTest, oPC);
                    SetPCDislike(oTest, oPC);
                }
            }
        }
        oPC = GetNextPC();
    }
}

void main()
{
    //Autodislike
    object oPC = GetFirstPC();

    while(GetIsObjectValid(oPC))
    {
        if(!GetIsDM(oPC)) SetDislike(oPC);
        oPC = GetNextPC();
    }
}

//:://////////////////////////////////////////////
//:: OnExit  am_inc_battle
//:: Copyright © 2005 WRG!
//:://////////////////////////////////////////////
/*
              БОЕВАЯ БИБЛИОТЕКА
*/
//:://////////////////////////////////////////////
//:: Created By: Aiwan
//:: Created On: 27.05.2005
//:://///////////////////////////////////////////

// ФУНКЦИЯ ОЧИСТКИ РЕПУТАЦИИ И СМЕНА ВСЕХ НПС НА ЛОКАЦИИ ФРАКЦИИ ВРАГА
// НА НЕЙТРАЛЬНУЮ
// object oPlayer - Игрок к которому враждебен oEnemy
// object oNetral - Объект с новой фракцией
// Если не указать кто именно, просто очистит репутацию
void ChangeEnemyToNetral(object oPlayer, object oNetral);
// ФУНКЦИЯ ПЕРЕВОДИТ ВСЕХ НПС НА ЛОКАЦИИ ОДНОЙ ФРАКЦИИ oLeader
// ВО ВРАЖДЕБНУЮ - STANDARD_FACTION_HOSTILE
// object oPlayer - Объект к кому будут фраждебны
// object oLeader=OBJECT_SELF - Если не указать кто именно
void ChangeNetralToEnemy(object oPlayer, object oLeader=OBJECT_SELF);

// ФУНКЦИЯ ОЧИСТКИ РЕПУТАЦИИ И СМЕНА ФРАКЦИИ ВРАГА НА СТАНДАРТНУЮ STANDARD_FACTION_*
// object oObjectToChangeFaction - наш враждебный элемент
// Указать стандартную фракцию nStandardFaction: STANDARD_FACTION_*
void ChangeEnemyToStandard(object oObjectToChangeFaction, int nStandardFaction);

// ФУНКЦИЯ ОЧИЩАЕТ ВСЮ ПЕРСОНАЛЬНУЮ РЕПУТАЦИЮ У ФРАКЦИИ
void ClearFactionReputation(object oPC, object oFaction=OBJECT_SELF);

// ФУНКЦИЯ ОЧИЩАЕМ РЕПУТУТАЦИЮ ПОМОЩНИКОВ И ИГРОКА К oSource
// iClearAllActions - очищает все акции включая боевые
void ClearAllPersonalReputation(object oMaster, object oSource=OBJECT_SELF, int iClearAllActions = FALSE);

// ФУНКЦИЯ УДАЛЕНИЯ ВСЕХ МОНСТРОВ ИЗ ЭНКАУЧЕРОВ
// В локации объекта oTarget
void DestroyEncounterCreature(object oTarget = OBJECT_SELF);

//**************************************************
****************************
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 ChangeNetralToEnemy(object oPlayer, object oLeader=OBJECT_SELF)
{
    object oArea  = GetArea(oPlayer);
    object oEnemy = GetFirstObjectInArea(oArea);
    while (GetIsObjectValid(oEnemy))
        {
          if (GetFactionEqual(oEnemy, oLeader) && oEnemy != oLeader  && oEnemy!=oPlayer)
          {
            AssignCommand(oEnemy,ClearAllActions(TRUE));
            ClearPersonalReputation(oPlayer,oEnemy);
            ChangeToStandardFaction(oEnemy,STANDARD_FACTION_HO
STILE);
          }
        oEnemy = GetNextObjectInArea(oArea);
        }
    DelayCommand(1.0, AssignCommand(oLeader,ClearAllActions(TRUE)));
    DelayCommand(1.0, ChangeToStandardFaction(oLeader,STANDARD_FACTION_H
OSTILE));
}
//------------------------------------------------------------------------------
void ChangeEnemyToStandard(object oObjectToChangeFaction, int nStandardFaction)
{
    object oPlayer = GetFirstPC();
    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);
    if (GetIsObjectValid(oObjectToChangeFaction))
    {
              if (GetIsEnemy(oPlayer,oObjectToChangeFaction))
                {
//----------------------- Обработка помощников -------------------------------//
                if(oAnimal != OBJECT_INVALID) {
                AssignCommand(oAnimal,ClearAllActions(TRUE));
                ClearPersonalReputation(oAnimal,oObjectToChangeFac
tion);}
                if(oDominated != OBJECT_INVALID){
                AssignCommand(oDominated,ClearAllActions(TRUE));
                ClearPersonalReputation(oDominated,oObjectToChange
Faction);}
                if(oFamiliar != OBJECT_INVALID){
                AssignCommand(oFamiliar,ClearAllActions(TRUE));
                ClearPersonalReputation(oFamiliar,oObjectToChangeF
action);}
                if(oSummoned != OBJECT_INVALID){
                AssignCommand(oSummoned,ClearAllActions(TRUE));
                ClearPersonalReputation(oSummoned,oObjectToChangeF
action);}
                int i = 1;
                object oHench = GetHenchman(oPlayer, i);
                  while(oHench != OBJECT_INVALID)
                    {
                    AssignCommand(oHench,ClearAllActions(TRUE));
                    ClearPersonalReputation(oHench,oObjectToChangeFact
ion);
                    i++;
                    oHench = GetHenchman(oPlayer, i);
                    }
                AssignCommand(oObjectToChangeFaction,ClearAllActio
ns(TRUE));
                ClearPersonalReputation(oPlayer,oObjectToChangeFac
tion);
                ChangeToStandardFaction(oObjectToChangeFaction, nStandardFaction);
                  }
    }
}
//------------------------------------------------------------------------------
void ClearFactionReputation(object oPC, object oFaction=OBJECT_SELF)
{
    object oMember = GetFirstFactionMember(oFaction, FALSE);

    while (oMember != OBJECT_INVALID)
    {
        ClearPersonalReputation(oPC, oMember);
        oMember = GetNextFactionMember(oFaction, 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 DestroyEncounterCreature(object oTarget = OBJECT_SELF)
{
object oCreaturse = GetFirstObjectInArea(GetArea(oTarget));
while (oCreaturse!=OBJECT_INVALID)
{
    if(GetIsEncounterCreature(oCreaturse) == TRUE)
    {
      DestroyObject(oCreaturse);
    }
    oCreaturse = GetNextObjectInArea(GetArea(oTarget));
}
}
//------------------------------------------------------------------------------
/*
void main(){}