void TeleportObject( string sZone, string sWayPont )
{

  object oPlayer = GetPCSpeaker();
  object oArea = GetObjectByTag( sZone );
  float fOrientation = GetFacing( oPlayer );
  vector vPosition = GetPosition( GetObjectByTag( sWayPont ) );

  location lWhereToGo = Location( oArea, vPosition, fOrientation );

  AssignCommand( oPlayer, JumpToLocation( lWhereToGo ) );
}

#include "NW_I0_TOOL"

void main()
{
  if ( CheckPartyForItem( GetFirstPC(), "itmMiscClair" ) == FALSE )
  {
    CreateItemOnObject( "itmmiscclair", GetFirstPC() );
  }
}

void main()
{
    object oPC;
    oPC=GetEnteringObject();
    SetLocalInt(oPC,"InZone",1);
}

void main()
{
    object oPC;
    oPC = GetExitingObject();
    SetLocalInt(oPC,"InZone",0);
}

void main()
{
    if(GetIsPC(GetLastPerceived()))
    {
        SignalEvent(OBJECT_SELF,EventUserDefined(200));
    }
}

void main()
{
    object oPC = GetNearestCreature(CREATURE_TYPE_PLAYER_CHAR, PLAYER_CHAR_IS_PC );
    switch(GetUserDefinedEventNumber())
   {
        case 200:
        {
            if(!IsInConversation(OBJECT_SELF) && GetLocalInt(oPC,"InZone") == 0)
            {
                ActionAttack(GetNearestObjectByTag("InvisibleObject"));
                DelayCommand(12.0,ClearAllActions());
                DelayCommand(24.0,SignalEvent(OBJECT_SELF,EventUserDefined(200)));
            }
            else
            {
                DelayCommand(12.0,SignalEvent(OBJECT_SELF,EventUserDefined(200)));
            }
        }
    }
}

object oPC = GetLastUsedBy();

void main()
{
        effect eVis = EffectVisualEffect(VFX_DUR_GHOSTLY_VISAGE);
        location lLoc = GetLocation(GetNearestObjectByTag("WP_Esprit"));
        object oEsprit = CreateObject(OBJECT_TYPE_CREATURE,"esprit",lLoc,TRUE);
        ApplyEffectAtLocation(DURATION_TYPE_INSTANT,EffectVisualEffect(VFX_FNF_SUMMON_GATE),lLoc);
        ApplyEffectToObject(DURATION_TYPE_TEMPORARY,eVis,oEsprit);
}

void main()
{
    ActionStartConversation(GetLastPerceived(), "esprit",TRUE);
}

#include "NW_I0_Plot"
void main()
{
    effect eVis = EffectVisualEffect(VFX_IMP_UNSUMMON);
    ApplyEffectToObject(DURATION_TYPE_INSTANT,eVis,OBJECT_SELF);
    DestroyObject(OBJECT_SELF,0.5f);
    PlayOldTheme();
}

#include "nw_i0_plot"
void main()
{
    object oRespawner = GetLastRespawnButtonPresser();
    ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectResurrection(),oRespawner);

    if (!GetLocalInt(GetModule(), "get_armeMGK") == 0) // ici on vérifie si l'arme magique a bien été trouvée
   {
   string sDestTag =  "RespawnPoint"; // ça c'est le tag du waypoint de téléportation, situé dans le temple ; si vous le changez, pensez aussi à le modifier ici...

   if (GetIsObjectValid(GetObjectByTag(sDestTag)))
     {

        if (sDestTag == "RespawnPoint") // ... et ici aussi
        {
            object oPriest = GetObjectByTag("NW_DEATH_CLERIC");

            AssignCommand(oPriest, DelayCommand(2.1, PlayVoiceChat(VOICE_CHAT_TALKTOME, oPriest)));

            SetLocalLocation(oRespawner, "NW_L_I_DIED_HERE", GetLocation(GetLastRespawnButtonPresser()));
            SetLocalInt(oRespawner, "NW_L_I_DIED", 1);
            SetLocalObject(oPriest, "NW_L_LASTDIED", GetLastRespawnButtonPresser());
        }


        object oSpawnPoint = GetObjectByTag(sDestTag);
        SetLocalInt (oRespawner, "mort", 1);
        AssignCommand(oRespawner,JumpToLocation(GetLocation(oSpawnPoint)));
        // * mak
     }
   }
   else
   {
    //Respawn après : résurrect sur place mise en place des token -1 constits :

    object oRez = GetLastRespawnButtonPresser();
    ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectHeal(GetMaxHitPoints(oRespawner)), oRespawner);
    RemoveEffects(oRespawner);  // ces 2 lignes soignent le joueur de tous ses maux, chose que le script ne faisait pas en le ramenant dans le temple.
    int nNbRez = GetLocalInt(oRez, "nNbRez");
    nNbRez++;
    if (nNbRez <=10)
    {
      DestroyObject(GetItemInSlot(INVENTORY_SLOT_CARMOUR, oRez));
      object oPenRez = CreateItemOnObject("constit"+IntToString(nNbRez), oRez);
      AssignCommand(oRez, ActionEquipItem(oPenRez, INVENTORY_SLOT_CARMOUR));
      SetLocalInt(oRez, "nNbRez", nNbRez);
    }
    }
}

// Effet special: fx: VFX_*, time : en seconde, type de dommage DAMAGE_TYPE_*
struct FX
{
  int fx;
  float time;
  int damage;
  int damageType;
  int damageMin;
  int damageMax;
};

// Creer un portail:
// - oCaller : personne appelant le portail
// - lUserItemLoc : location ou creet le portail
// - Structure Portail
object CreatePortail( object oCaller, location lUserItemLoc, struct FX cBeam, struct FX cAura, int iType = 0 );

object CreatePortail( object oCaller, location lUserItemLoc, struct FX cBeam, struct FX cAura, int iType = 0 )
{
  int bCanCreate = TRUE;

  object oPortail = OBJECT_INVALID;

  /////////////////////////////////////////////////////
  /* Partie a modifier selon le type d'action voulue */
  if ( iType == 0 &&
       GetIsPC( oCaller ) &&
       GetLocalInt( GetModule(), "bal_portail_used_by_" + GetPCPlayerName( oCaller ) )
       == TRUE )
  {
    FloatingTextStringOnCreature( GetPCPlayerName( oCaller ) + " : vous avez deja ouvert un portail.", oCaller, FALSE );
    bCanCreate = FALSE;
  }
  /* Partie a modifier selon le type d'action voulue */
  /////////////////////////////////////////////////////

  if ( bCanCreate == TRUE )
  {
    effect eEffect = EffectVisualEffect( VFX_DUR_ELEMENTAL_SHIELD );
    effect eEffect2 = EffectVisualEffect( cAura.fx );

    ApplyEffectAtLocation( DURATION_TYPE_TEMPORARY, eEffect, lUserItemLoc, 3.0);
    oPortail = CreateObject( OBJECT_TYPE_PLACEABLE, "teleport_portail", lUserItemLoc, FALSE );
    ApplyEffectAtLocation( DURATION_TYPE_TEMPORARY, eEffect2, lUserItemLoc, cAura.time );

    effect eLightning = EffectBeam( cBeam.fx, oPortail, BODY_NODE_CHEST );

    float fDelay = 0.2;

    object oTarget = GetFirstObjectInShape( SHAPE_SPHERE, RADIUS_SIZE_COLOSSAL, lUserItemLoc, TRUE, OBJECT_TYPE_CREATURE | OBJECT_TYPE_DOOR | OBJECT_TYPE_ITEM | OBJECT_TYPE_PLACEABLE );

    int iDamageRange = abs( cBeam.damageMax - cBeam.damageMin );
    effect eDamage;

    while ( GetIsObjectValid( oTarget ) )
    {
      if ( oTarget != oPortail )
      {
        DelayCommand(fDelay, ApplyEffectToObject( DURATION_TYPE_TEMPORARY, eLightning, oTarget, cBeam.time ) );

        if ( cBeam.damage == TRUE && iDamageRange > 0 )
        {
          eDamage = EffectDamage( ( cBeam.damageMin + Random( iDamageRange ) + 1 ), cBeam.damageType );
          DelayCommand( 0.0, ApplyEffectToObject( DURATION_TYPE_INSTANT, eDamage, oTarget ) );
        }
      }
      fDelay = fDelay + 0.1f;

     oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_COLOSSAL, lUserItemLoc, TRUE, OBJECT_TYPE_CREATURE | OBJECT_TYPE_DOOR | OBJECT_TYPE_ITEM |  OBJECT_TYPE_PLACEABLE );
    }

    /* Type de portails
       0. portail prive de teleportation
    */

    /////////////////////////////////////////////////////
    /* Partie a modifier selon le type d'action voulue */
    if ( iType == 0 && GetIsPC( oCaller ) )
    {
      SetLocalInt( oPortail   , "bal_portail_type", iType );
      SetLocalString( oPortail, "bal_portail_user", GetPCPlayerName( oCaller ) );
      SetLocalInt( GetModule(), "bal_portail_used_by_" + GetPCPlayerName( oCaller ), 1 );
    }
    /* Partie a modifier selon le type d'action voulue */
    /////////////////////////////////////////////////////
  }

  return oPortail;
}

struct FX
{
  int fx;
  float time;
  int damage;
  int damageType;
  int damageMin;
  int damageMax;
};

object CreatePortail( object oCaller, location lUserItemLoc, struct FX cBeam, struct FX cAura, int iType = 0 )

  /////////////////////////////////////////////////////
  /* Partie a modifier selon le type d'action voulue */
  if ( iType == 0 &&
       GetIsPC( oCaller ) &&
       GetLocalInt( GetModule(), "bal_portail_used_by_" + GetPCPlayerName( oCaller ) )
       == TRUE )
  {
    FloatingTextStringOnCreature( GetPCPlayerName( oCaller ) + " : vous avez deja ouvert un portail.", oCaller, FALSE );
    bCanCreate = FALSE;
  }
  /* Partie a modifier selon le type d'action voulue */
  /////////////////////////////////////////////////////

    /////////////////////////////////////////////////////
    /* Partie a modifier selon le type d'action voulue */
    if ( iType == 0 && GetIsPC( oCaller ) )
    {
      SetLocalInt( oPortail   , "bal_portail_type", iType );
      SetLocalString( oPortail, "bal_portail_user", GetPCPlayerName( oCaller ) );
      SetLocalInt( GetModule(), "bal_portail_used_by_" + GetPCPlayerName( oCaller ), 1 );
    }
    /* Partie a modifier selon le type d'action voulue */
    /////////////////////////////////////////////////////

------------------------------------------------------------------
//besoin pour les fonctions de tests sur l'inventaire
#include "nw_i0_tool"

void main()
{
  //def du perso qui cause au portail
  object oClicker = GetPCSpeaker();

  //def du portail cible
  object oTarget;

  //test pour savoir si une cle speciale est demandee
  int iKeyRequired = GetLockKeyRequired(OBJECT_SELF);

  //recuperation du nom de cette fameuse cle
  string sKeyRequiredTag = GetLockKeyTag(OBJECT_SELF);

  //recuperation du tag du portail
  string sSourceName = GetTag(OBJECT_SELF);

  //on compte sa longueur
  int iSourceNameLength =  GetStringLength( sSourceName );

  //on recupere le dernier caractere du nom
  string sLastCharacter = GetStringRight( sSourceName, 1 );

  //def du nouveau dernier caractere
  string sNewLastCharacter ;

  //recuperation du nom moins le dernier caractere
  string sSourceNameBegining = GetStringLeft( sSourceName, iSourceNameLength -1 );

  //test sur le dernier caractere, si A alors devient B et reciproquement
  if ( sLastCharacter == "A" ){ sNewLastCharacter = "B";}
  if ( sLastCharacter == "B" ){ sNewLastCharacter = "A";}
 
  //la cible du portail devient le debut du nom + le nouveau dernier caractere
  oTarget = GetObjectByTag(sSourceNameBegining + sNewLastCharacter);

  // affichage de transition
  SetAreaTransitionBMP(AREA_TRANSITION_RANDOM);

  //si la cle est requise, test pour savoir si l'equipe l'a
  if (iKeyRequired == TRUE ){
  if (CheckPartyForItem(oClicker, sKeyRequiredTag))
  {

  // si oui alors on saute vers la cible
    AssignCommand(oClicker,JumpToObject(oTarget));
  }

  else
  {

  //si non texte...
    SpeakString("Vous n'avez pas la bonne cle.");
  }}
  else { AssignCommand(oClicker,JumpToObject(oTarget));}

}

// Pour faire disparaitre un NPC //
// avec un effet qui persiste    //
// meme si le NPC a disparu      //
///////////////////////////////////

void main()
{
//On definit l'objet qui va disparaitre = oNPC,
object oNPC = GetObjectByTag("Ange001");

//On crée l'objet invisible sur lequel on va appliquer l'effet,
//il apparait a l'endroit ou est le NPC,
object oTarget = CreateObject(OBJECT_TYPE_PLACEABLE,"effetdeladestruc",GetLocation(oNPC));

//On determine l'effet a appliquer sur l'objet invisible,
effect eEffet = EffectVisualEffect(VFX_IMP_DEATH_L);

//On defini l'objet sur lequel va etre applique l'effet,
object oInvisible = GetNearestObjectByTag("EffetdelaDestructiondelAnge");

//ATTENTION: il y a un DelayCommand de 0.15, il est necessaire,
//car si le delai est inferieur a 0.15 ou s'il n'y a pas de delai,
//l'objet invisible n'a pas le temps d'apparaitre,
//donc l'effet ne peut etre applique,

//On applique l'effet a l'objet invisible,
DelayCommand(0.15,ApplyEffectToObject(DURATION_TYPE_INSTANT,eEffet,oInvisible));

//On fait disparaitre le NPC (c'est un ange dans mon exemple !!!),
DelayCommand(0.15,DestroyObject(oNPC));

//On detruit l'objet invisible qui ne sert plus a rien,
DelayCommand(10.0,DestroyObject(oInvisible));

//Et voila !!!
}

void main()
{
    object oPC = GetLastPCRested();
     
    string sArea = GetTag(GetArea(oPC));
     
    if (sArea == "Tag De L'Auberge1")
    {
        if( ! GetIsObjectValid(GetItemPossessedBy(oPC, "Tag de la clé1")))
        {
            AssignCommand(oPC, ClearAllActions());
            SendMessageToPC(oPC, "Vous ne pouvez pas dormir à l'auberge sans payer votre chambre !");
        }
    }
    else if (sArea == "Tag De L'Auberge2")
    {
        if( ! GetIsObjectValid(GetItemPossessedBy(oPC, "Tag de la clé2")))
        {
            AssignCommand(oPC, ClearAllActions());
            SendMessageToPC(oPC, "Vous ne pouvez pas dormir à l'auberge sans payer votre chambre !");
        }
    }
    else if (sArea == "Tag De L'Auberge3")
    {
        if( ! GetIsObjectValid(GetItemPossessedBy(oPC, "Tag de la clé3")))
        {
            AssignCommand(oPC, ClearAllActions());
            SendMessageToPC(oPC, "Vous ne pouvez pas dormir à l'auberge sans payer votre chambre !");
        }
    }
    else
    {
        if( ! GetIsObjectValid(GetItemPossessedBy(oPC, "Tag du kit")))
        {
            AssignCommand(oPC, ClearAllActions());
            SendMessageToPC(oPC, "Vous ne pouvez pas dormir à la belle étoile sans sac de couchage !");
        }
    }

}

//::///////////////////////////////////////////////
//:: Heartbeat personnalise
//:: RAV_ANIMHB
//:://////////////////////////////////////////////
/*
    Animations personnalisees
*/
//:://////////////////////////////////////////////
//:: Created By: Serge GANDOLPHE
//:: Created On: 13 fevrier 2003
//:://////////////////////////////////////////////
#include "NW_I0_GENERIC"
#include "nw_i0_plot"

void main()
{

    //if(!GetIsInCombat() && !IsInConversation(OBJECT_SELF))
    //    ActionRandomWalk();

    if(GetSpawnInCondition(NW_FLAG_FAST_BUFF_ENEMY))
    {
        if(TalentAdvancedBuff(40.0))
        {
            SetSpawnInCondition(NW_FLAG_FAST_BUFF_ENEMY, FALSE);
            return;
        }
    }

    if(GetSpawnInCondition(NW_FLAG_DAY_NIGHT_POSTING))
    {
        int nDay = FALSE;
        if(GetIsDay() || GetIsDawn())
        {
            nDay = TRUE;
        }
        if(GetLocalInt(OBJECT_SELF, "NW_GENERIC_DAY_NIGHT") != nDay)
        {
            if(nDay == TRUE)
            {
                SetLocalInt(OBJECT_SELF, "NW_GENERIC_DAY_NIGHT", TRUE);
            }
            else
            {
                SetLocalInt(OBJECT_SELF, "NW_GENERIC_DAY_NIGHT", FALSE);
            }
            WalkWayPoints();
        }
    }

    if(!GetHasEffect(EFFECT_TYPE_SLEEP))
    {
        if(!GetIsPostOrWalking())
        {
            if(!GetIsObjectValid(GetAttemptedAttackTarget()) && !GetIsObjectValid(GetAttemptedSpellTarget()))
            {
                if(!GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)))
                {
                    if(!GetBehaviorState(NW_FLAG_BEHAVIOR_SPECIAL) && !IsInConversation(OBJECT_SELF))
                    {
                        if(GetSpawnInCondition(NW_FLAG_AMBIENT_ANIMATIONS) || GetSpawnInCondition(NW_FLAG_AMBIENT_ANIMATIONS_AVIAN))
                        {
                            PlayMobileAmbientAnimations();
                        }
                        else if(GetIsEncounterCreature() &&
                        !GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)))
                        {
                            PlayMobileAmbientAnimations();
                        }
                        else if(GetSpawnInCondition(NW_FLAG_IMMOBILE_AMBIENT_ANIMATIONS) &&
                           !GetIsObjectValid(GetNearestCreature(CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, OBJECT_SELF, 1, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN)))
                        {
                            PlayImmobileAmbientAnimations();
                        }
                    }
                    else
                    {
                        DetermineSpecialBehavior();
                    }
                }
                else
                {
                    //DetermineCombatRound();
                }
            }
        }
    }
    else
    {
        if(GetSpawnInCondition(NW_FLAG_SLEEPING_AT_NIGHT))
        {
            effect eVis = EffectVisualEffect(VFX_IMP_SLEEP);
            if(d10() > 6)
            {
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, OBJECT_SELF);
            }
        }
    }
    if(GetSpawnInCondition(NW_FLAG_HEARTBEAT_EVENT))
    {
        SignalEvent(OBJECT_SELF, EventUserDefined(1001));
    }

    //Ca se passe ici
    /*Le jour le pnj se ballade dans le village et a la tombee de la nuit il rentre chez lui*/
        if(GetLocalInt(OBJECT_SELF,"isoutside"))
        {
            if((GetIsNight() || GetIsDusk()) && !GetLocalInt(OBJECT_SELF,"movedinside")){
                SetLocalInt(OBJECT_SELF,"isoutside", FALSE);
                SetLocalInt(OBJECT_SELF,"movedoutside",FALSE);
                SetLocalInt(OBJECT_SELF,"movedinside",TRUE);
                ClearAllActions(TRUE);
                EscapeArea(FALSE,"EXIT_"+GetTag(OBJECT_SELF));
                object OPnj = CreateObject(OBJECT_TYPE_CREATURE,GetResRef(OBJECT_SELF),GetLocation(GetWaypointByTag("NIGHT_"+GetTag(OBJECT_SELF))));
                DestroyObject(OBJECT_SELF,10.0f);//Pour etre certain de ne pas avoir de clones
            }
        }
        else{
            if((GetIsDay() || GetIsDawn()) && !GetLocalInt(OBJECT_SELF,"movedoutside")){
                SetLocalInt(OBJECT_SELF,"isoutside", TRUE);
                SetLocalInt(OBJECT_SELF,"movedoutside",TRUE);
                SetLocalInt(OBJECT_SELF,"movedinside",FALSE);
                ClearAllActions(TRUE);
                EscapeArea(FALSE,"EXIT_"+GetTag(OBJECT_SELF));
                object OPnj = CreateObject(OBJECT_TYPE_CREATURE,GetResRef(OBJECT_SELF),GetLocation(GetWaypointByTag("DAY_"+GetTag(OBJECT_SELF))));
                DestroyObject(OBJECT_SELF,10.0f);
            }
        }
}

//::///////////////////////////////////////////////
//:: Default: On Spawn In
//:: rav_os_commoner
//:: Par Serge GANDOLPHE
//:://////////////////////////////////////////////
/*
    Determines the course of action to be taken
    after having just been spawned in
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Oct 25, 2001
//:://////////////////////////////////////////////
#include "NW_O2_CONINCLUDE"
#include "NW_I0_GENERIC"

void main()
{
    //Ici il faut lister vos zones de JOUR!!!!
    //Remplacez simplement zone1 et zone2 par les tags de vos zones et rajoutez autant de  || areaTag =="zonex" que vous avez de zones de jour
    string areaTag = GetTag(GetArea(OBJECT_SELF));
    if(areaTag =="zone1" || areaTag =="zone2" ){
        SetLocalInt(OBJECT_SELF,"isoutside", TRUE);
        SetLocalInt(OBJECT_SELF,"movedoutside",TRUE);
        SetLocalInt(OBJECT_SELF,"movedinside",FALSE);
    }
    else{
        SetLocalInt(OBJECT_SELF,"isoutside", FALSE);
        SetLocalInt(OBJECT_SELF,"movedoutside",FALSE);
        SetLocalInt(OBJECT_SELF,"movedinside",TRUE);
    }
// OPTIONAL BEHAVIORS (Comment In or Out to Activate ) ****************************************************************************
     //SetSpawnInCondition(NW_FLAG_SPECIAL_CONVERSATION);
     //SetSpawnInCondition(NW_FLAG_SPECIAL_COMBAT_CONVERSATION);
                // This causes the creature to say a special greeting in their conversation file
                // upon Perceiving the player. Attach the [NW_D2_GenCheck.nss] script to the desired
                // greeting in order to designate it. As the creature is actually saying this to
                // himself, don't attach any player responses to the greeting.

     //SetSpawnInCondition(NW_FLAG_SHOUT_ATTACK_MY_TARGET);
                // This will set the listening pattern on the NPC to attack when allies call
     //SetSpawnInCondition(NW_FLAG_STEALTH);
                // If the NPC has stealth and they are a rogue go into stealth mode
     //SetSpawnInCondition(NW_FLAG_SEARCH);
                // If the NPC has Search go into Search Mode
     //SetSpawnInCondition(NW_FLAG_SET_WARNINGS);
                // This will set the NPC to give a warning to non-enemies before attacking

     //SetSpawnInCondition(NW_FLAG_SLEEP);
                //Creatures that spawn in during the night will be asleep.
     //SetSpawnInCondition(NW_FLAG_DAY_NIGHT_POSTING);
     //SetSpawnInCondition(NW_FLAG_APPEAR_SPAWN_IN_ANIMATION);
     //SetSpawnInCondition(NW_FLAG_IMMOBILE_AMBIENT_ANIMATIONS);
     //SetSpawnInCondition(NW_FLAG_AMBIENT_ANIMATIONS);
                //This will play Ambient Animations until the NPC sees an enemy or is cleared.
                //NOTE that these animations will play automatically for Encounter Creatures.

    // NOTE: ONLY ONE OF THE FOLOOWING ESCAPE COMMANDS SHOULD EVER BE ACTIVATED AT ANY ONE TIME.
    //SetSpawnInCondition(NW_FLAG_ESCAPE_RETURN);    // OPTIONAL BEHAVIOR (Flee to a way point and return a short time later.)
    //SetSpawnInCondition(NW_FLAG_ESCAPE_LEAVE);     // OPTIONAL BEHAVIOR (Flee to a way point and do not return.)
    //SetSpawnInCondition(NW_FLAG_TELEPORT_LEAVE);   // OPTIONAL BEHAVIOR (Teleport to safety and do not return.)
    //SetSpawnInCondition(NW_FLAG_TELEPORT_RETURN);  // OPTIONAL BEHAVIOR (Teleport to safety and return a short time later.)

// CUSTOM USER DEFINED EVENTS
/*
    The following settings will allow the user to fire one of the blank user defined events in the NW_D2_DefaultD.  Like the
    On Spawn In script this script is meant to be customized by the end user to allow for unique behaviors.  The user defined
    events user 1000 - 1010
*/
    //SetSpawnInCondition(NW_FLAG_HEARTBEAT_EVENT);        //OPTIONAL BEHAVIOR - Fire User Defined Event 1001
    //SetSpawnInCondition(NW_FLAG_PERCIEVE_EVENT);         //OPTIONAL BEHAVIOR - Fire User Defined Event 1002
    //SetSpawnInCondition(NW_FLAG_ATTACK_EVENT);           //OPTIONAL BEHAVIOR - Fire User Defined Event 1005
    //SetSpawnInCondition(NW_FLAG_DAMAGED_EVENT);          //OPTIONAL BEHAVIOR - Fire User Defined Event 1006
    //SetSpawnInCondition(NW_FLAG_DISTURBED_EVENT);        //OPTIONAL BEHAVIOR - Fire User Defined Event 1008
    //SetSpawnInCondition(NW_FLAG_END_COMBAT_ROUND_EVENT); //OPTIONAL BEHAVIOR - Fire User Defined Event 1003
    //SetSpawnInCondition(NW_FLAG_ON_DIALOGUE_EVENT);      //OPTIONAL BEHAVIOR - Fire User Defined Event 1004
    //SetSpawnInCondition(NW_FLAG_DEATH_EVENT);            //OPTIONAL BEHAVIOR - Fire User Defined Event 1007

// DEFAULT GENERIC BEHAVIOR (DO NOT TOUCH) *****************************************************************************************
    SetListeningPatterns();    // Goes through and sets up which shouts the NPC will listen to.
    WalkWayPoints();           // Optional Parameter: void WalkWayPoints(int nRun = FALSE, float fPause = 1.0)
                               // 1. Looks to see if any Way Points in the module have the tag "WP_" + NPC TAG + "_0X", if so walk them
                               // 2. If the tag of the Way Point is "POST_" + NPC TAG the creature will return this way point after
                               //    combat.
    GenerateNPCTreasure();     //* Use this to create a small amount of treasure on the creature
}

#include "nw_i0_tool"
void main()
{
 object oRigolo = GetLastDamager();
 //oRigolo est celui qui a touché le mannequin.
 object oGlups = OBJECT_SELF;
  //oGlups, c'est le mannequin.
  effect eBoum = EffectVisualEffect(VFX_FNF_SCREEN_SHAKE);
  //eBoum est un effet de tremblement d'écran qui est facultatif.
  int nDamage = GetTotalDamageDealt();
 //nDamage est le nombre de points de dommages qu'a reçu le mannequin.
if (GetIsPC(oRigolo))
  //Ici, on vérifie que oRigolo est bien un joueur.
  {
           if(nDamage > 99)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 100 ou plus.
           {
           SendMessageToPC(oRigolo, "Tricheur !");
           //On ne peut décement pas faire autant de dommages en un coup !
           DelayCommand(1.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectDeath(TRUE), oRigolo));
           //Bref, on tue le tricheur sans sommations !
                         }
                         else
                         {
           if(nDamage > 59)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 60 ou plus.
           {
           RewardPartyXP(20, oRigolo);
           //On offre 20 xp au joueur.
           SendMessageToPC(oRigolo, "CHAMPION DU MONDE !!!");
           //Un petit message au joueur...
           ApplyEffectToObject(DURATION_TYPE_INSTANT, eBoum, oGlups);
           DelayCommand(2.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eBoum, oGlups));
           DelayCommand(4.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eBoum, oGlups));
           //L'effet de tremblement. On peut le supprimer sans aucun problème.
                        }
           else
             {
            if(nDamage > 49)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 50 ou plus.
           {
           RewardPartyXP(10, oRigolo);
            //On offre 10 xp au joueur.
          SendMessageToPC(oRigolo, "CHAMPION !");
           //Un petit message au joueur...
           ApplyEffectToObject(DURATION_TYPE_INSTANT, eBoum, oGlups);
            //L'effet de tremblement. On peut le supprimer sans aucun problème.
                         }
           else
             {
            if(nDamage > 39)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 40 ou plus.
           {
           RewardPartyXP(8, oRigolo);
            //On offre 8 xp au joueur.
           SendMessageToPC(oRigolo, "Champion !");
            //Un petit message au joueur...
              }
           else
             {
            if(nDamage > 29)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 30 ou plus.
           {
           RewardPartyXP(6, oRigolo);
            //On offre 6 xp au joueur.
           SendMessageToPC(oRigolo, "Des muscles d'acier !");
             //Un petit message au joueur...
             }
           else
             {
           if(nDamage > 19)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 20 ou plus.
           {
           RewardPartyXP(4, oRigolo);
             //On offre 4 xp au joueur.
           SendMessageToPC(oRigolo, "Quelle force !");
             //Un petit message au joueur...
             }
           else
             {
          if(nDamage > 14)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 15 ou plus.
           {
           RewardPartyXP(3, oRigolo);
            //On offre 3 xp au joueur.
           SendMessageToPC(oRigolo, "Impressionant !");
             //Un petit message au joueur...
             }
           else
             {
           if(nDamage > 9)
           //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 10 ou plus.
           {
           RewardPartyXP(2, oRigolo);
             //On offre 2 xp au joueur.
           SendMessageToPC(oRigolo, "Pas mal !");
             //Un petit message au joueur...
             }
           else
             {
            if(nDamage > 4)
            //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 5 ou plus.
                {
                 RewardPartyXP(1, oRigolo);
                  //On offre 1 xp au joueur.
                SendMessageToPC(oRigolo, "Bof !");
                //Un petit message au joueur...
                }
                else
                {
                if(nDamage > 2)
            //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 3 ou plus.
                {
                SendMessageToPC(oRigolo, "Pas terrible !");
                //Un petit message au joueur...
                }
                else
               //Ce qui suit entre accolades est ce qui se passera si nDamage vaut 1 ou 2.
                {
                SendMessageToPC(oRigolo, "Mauviette !");
               //Un petit message au joueur...
              }
              }
              }
              }
              }
              }
              }
              }
              }
              }
              }
              else
              //Ce qui suit entre accolades est ce qui se passera si oRigolo n'est pas un joueur.
              {
              ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectHeal(nDamage), oGlups);
              //On guérit le mannequin des dommages qu'il vient de recevoir( cela n'arrive donc que si une autre créature attaque le mannequin ).
              }
              }

void main()
{
    object oPC = GetLastAttacker();
    SetIsTemporaryFriend(oPC,OBJECT_SELF,FALSE,0.001);
    DelayCommand(0.001,SetIsTemporaryEnemy(oPC));
}

//://////////////////////////////////////////////
//:: FileName : Placable destructible que par une arme
//://///////////////////////////////////////////
//://///////////////////////////////////////////
//:: Created By: Albator003
//:: Created On:
//://///////////////////////////////////////////
void main()
{
object oPJ = GetLastDamager(); // On prend le dernier joueur qui attaque le placable
if(GetTag(GetLastWeaponUsed(oPJ)) == ("Tag de l'arme perso")) // On regarde si il possde l'arme pour dtruire le placable dans ce cas il la possde
{
effect eCasse = EffectVisualEffect(VFX_IMP_DEATH,VFX_FNF_LOS_EVIL_30); //Quelques effets visuelles pour que ce soit un peu plus beau
effect eCasse1 = EffectVisualEffect(VFX_IMP_LIGHTNING_M,VFX_DUR_WEB_MASS); //idem
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eCasse, GetLocation(OBJECT_SELF)); //Execution des effet pour le cas ou il possede l'arme
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eCasse1, GetLocation(OBJECT_SELF)); // Idem
DestroyObject(GetObjectByTag("Tag de votre placable")); //On detruit le placable
}
{
if(GetTag(GetLastWeaponUsed(oPJ)) != ("Tag de l'arme perso")) // On regarde si le joueur a l'arme (ici il ne la pas)

ActionSpeakString("*Vous touchez l'autel mais n'y faite aucune égratignure*"); // On lui signal que c'est pas la peine de s'acharner dessus lol
}
}

//::///////////////////////////////////////////////
//:: Name    tutu_transe
//:: FileName
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*mettez ce script sous le nom de "tutu_transe" dans votre liste de scripts du module
Modifier le script NW_C2_DEFAULT3 ( c'est le script de fin de round ). Ensuite creez
une arme quelconque et donnez lui le tag de trance_01, trance_02 ou trance_99. Lorsque
vous utiliserez une de ces armes dans votre module, au bout d'un certain nombre de combats,
votre perso va entrer en transe et devenir beaucoup plus fort. Cette periode dure un court
instant et apres il perd beaucoup plus de puissance qu'avant la transe. Cette periode
des effets secondaires dure 90sec (modifiable).
Je me suis inspire d'un script deja poste sur NW Vault :
http://nwvault.ign.com/Files/scripts/data/1040734959970.shtml

A noter que lorsque le PJ quitte un combat pendant la transe, lorsqu'il rencontrera
de nouveau un ennemi il reviendra a l'etat de transe, tandis que les effets de la
contretranse sont predefinis.
*/
//:://////////////////////////////////////////////
//:: Created By:   Marvin Kosh
//:: Modified By:  Tuyen
//:://////////////////////////////////////////////
void main()
{
    // ***********************DEFINITION DES VARIABLES***************************
    object oTranse = OBJECT_SELF;
    int iTemps = GetLocalInt(oTranse, "temps");

    // Definir le nombre de Hit Point max et actuel du perso
    int iMaxHP = GetMaxHitPoints(oTranse);
    int iCurHP = GetCurrentHitPoints(oTranse);
    string sWeapon = GetTag(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oTranse));

    // Definir le type de transe
    int iTranceProcess = StringToInt(GetSubString(sWeapon, 7, 2));

    // Definir les dialogues d'entree et de sortie de transe
    string sTranceStart = "*Transe!*";
    string sTranceEnd = "Vous sentez les effets de la transe vous quitter.";

    // Definir la duree du temps de transe et de contretranse
    float fEffectDur = 10.0;//Ne pas changer cette valeur
    float fSideEffectDur = 90.0; /*Changez cette valeur si vous voulez que
    les effets negatifs durent plus longtemps*/

    // Definir les effets de transe et de contretranse
    effect TranceEffect1;
    effect TranceEffect2;
    effect TranceEffect3;
    effect TranceEffect4;
    effect TranceSideEffect1;
    effect TranceSideEffect2;
    effect TranceSideEffect3;

    /* Definir les effets pour chaque type de transe : Chaque cas correspond a
    un type de transe different. Vous pouvez creer des transes qui ameliorent
    les capacites de combat ou plutot ceux de magie, et aussi modifier leurs
    puissances. Pour cela utiliser les fonctions de type 'Effect***' et ajouter
    cases entre case 1 et case 99 ne pas oublier de les declater en haut si vous
    voulez ajoutez plus de 4 effets pour un type de transe. */

    switch(iTranceProcess)
        {
        case 1:
        TranceEffect1 = EffectAbilityIncrease(ABILITY_STRENGTH, 10);
        TranceEffect2 = EffectHaste();
        TranceEffect3 = EffectVisualEffect(VFX_FNF_LOS_HOLY_30, FALSE);
        TranceEffect4 = EffectVisualEffect(VFX_DUR_PROTECTION_GOOD_MAJOR, FALSE);
        break;
        case 2:
        TranceEffect1 = EffectSpellResistanceIncrease(25);
        TranceEffect2 = EffectDamageReduction(10, DAMAGE_POWER_PLUS_TWO, 100);
        TranceEffect3 = EffectVisualEffect(VFX_IMP_HARM, FALSE);
        TranceEffect4 = EffectVisualEffect(VFX_DUR_SANCTUARY, FALSE);
        break;
        case 99:
        TranceEffect1 = EffectDamageIncrease(DAMAGE_BONUS_2d6, DAMAGE_TYPE_NEGATIVE);
        TranceEffect2 = EffectAttackIncrease(10, ATTACK_BONUS_MISC);
        TranceEffect3 = EffectVisualEffect(VFX_DUR_PROTECTION_EVIL_MAJOR, FALSE);
        TranceEffect4 = EffectVisualEffect(VFX_DUR_PROTECTION_ELEMENTS, FALSE);
        break;
        }

    // Definir les effets de contretranse pour chaque type de transe
    switch (iTranceProcess)
        {
        case 1:
        TranceSideEffect1 = EffectAbilityDecrease(ABILITY_STRENGTH, 14);
        TranceSideEffect2 = EffectSlow();
        TranceSideEffect3 = EffectVisualEffect(VFX_IMP_DISPEL, FALSE);
        break;
        case 2:
        TranceSideEffect1 = EffectSpellResistanceDecrease(25);
        TranceSideEffect2 = EffectDispelMagicAll(20);
        TranceSideEffect3 = EffectVisualEffect(VFX_IMP_DISPEL, FALSE);
        break;
        case 99:
        TranceSideEffect1 = EffectVisualEffect(VFX_IMP_DEATH, FALSE);
        TranceSideEffect2 = EffectSkillDecrease (SKILL_ALL_SKILLS, 20);
        TranceSideEffect3 = EffectVisualEffect(VFX_FNF_PWKILL, FALSE);
        break;
        }


    //************** C'EST LA QUE LES CHOSES SERIEUSES COMMENCENT **************
    //Incrementation de la variable temps d'un point
    iTemps = iTemps + 1;
    SetLocalInt(oTranse, "temps", iTemps);
    //Enlevez les commentaires de la ligne ci-dessous pour avoir le decompte des rounds
    //FloatingTextStringOnCreature(IntToString(iTemps), oTranse, FALSE);


    //Pendant 40 rounds, il ne se passe rien

    //A partir du 40ieme round et jusqu'au 47ieme round, le perso entre en transe
    if ((iTemps == 40) && (GetIsInCombat(oTranse)==TRUE))
      {
         FloatingTextStringOnCreature(sTranceStart, oTranse, FALSE);
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceEffect3, oTranse, fEffectDur);
      }
    //Application de divers effets
    if ((iTemps >= 40) && (iTemps < 47) && (GetIsInCombat(oTranse)==TRUE))
      {
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceEffect1, oTranse, fEffectDur);
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceEffect2, oTranse, fEffectDur);
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceEffect4, oTranse, fEffectDur);
      }
    //Au 47ieme round, c'est la fin de la transe, le perso se trouve sous des effets de
    //contretranse, qui le rabaissent. Ces effets durent
    if (iTemps == 47)
      {
         SendMessageToPC(oTranse, sTranceEnd);
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceSideEffect1, oTranse, fSideEffectDur);
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceSideEffect2, oTranse, fSideEffectDur);
         ApplyEffectToObject(DURATION_TYPE_TEMPORARY, TranceSideEffect3, oTranse, fSideEffectDur);
      }
    //Lorsque le compteur atteint 55, le remettre a 0
    if (iTemps == 55)
      {
         iTemps = 0;
      }
    SetLocalInt(oTranse, "temps", iTemps);

}

//::///////////////////////////////////////////////
//:: Default: End of Combat Round
//:: NW_C2_DEFAULT3
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
    Calls the end of combat script every round
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Modified By : Marvin Kosh
//:: Implemente dans ce module par : Votre serviteur Tuyen (o_o)
//:: Created On: Oct 16, 2001
//:://////////////////////////////////////////////

#include "NW_I0_GENERIC"
void main()
{
    // Modifications pour la transe
        // Definir le dernier ennemi( soit le PC, soit un autre NPC )
        object oTarget = GetLastAttacker();
        // definir l'armer principale utilisee ( main droie )
        object oMainWeapon =(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oTarget));
        // definir le tag de l'arme en tant que string
        string sTag = GetTag(oMainWeapon);
        // verifie si le tag commence par "transe_"
        // si c'est le cas lancer le script "tutu_transe" sur le dernier ennemi
        if (GetSubString(sTag, 0, 7) == "trance_")
        ExecuteScript("tutu_transe", oTarget);
    // Fin des modifications
    if(GetBehaviorState(NW_FLAG_BEHAVIOR_SPECIAL))
    {
        DetermineSpecialBehavior();
    }
    else if(!GetSpawnInCondition(NW_FLAG_SET_WARNINGS))
    {
       DetermineCombatRound();
    }
    if(GetSpawnInCondition(NW_FLAG_END_COMBAT_ROUND_EVENT))
    {
        SignalEvent(OBJECT_SELF, EventUserDefined(1003));
    }
}

void main()
{
object oPC;

if (!GetIsPC(GetItemActivatedTarget())
|| GetIsInCombat(GetItemActivator())
){

SendMessageToPC(GetItemActivator(), "Vous ne pouvez pas utiliser cet objet maintenant !");
return;}

object oTarget;
oPC = GetItemActivator();



oTarget = oPC;

AssignCommand(oTarget, ActionStartConversation(oPC, "nomdudial"));

}

void main()
{
object oPoubelle = GetObjectByTag("Tag de votre contenant");
object oPC = GetItemPossessor(oPoubelle);
object oObject = GetFirstItemInInventory(oPoubelle);
int nGold = 20;  //a vous de choisir combien vous voulez donné
while(GetIsObjectValid(oObject)==TRUE)
{
DestroyObject(oObject);
oObject = GetNextItemInInventory(oPoubelle);
GiveGoldToCreature(oPC, nGold);
}
}

/*******************************************************************************
**  Module      : Loreval Message Queue (prototype)                           **
**  Sous-Module : Systeme multi-canaux                                        **
**----------------------------------------------------------------------------**
**  Auteur               : Lendraste                                          **
**  Version              : 0.1b                                               **
**  Date de creation     : 14/08/2003                                         **
**  Date de modification : 16/08/2003                                         **
**  Compatibilites       : NWN 1.29+, SOU 1.30                                **
**----------------------------------------------------------------------------**
**  Module permettant la creation et la gestion de canaux et de liste de dif- **
**  fusion de message. Ce systeme s'appuie sur la presence d'un PNJ Listener  **
**----------------------------------------------------------------------------**
**  Historique                                                                **
**  14/08/2003 (v0.1b) : composition de la bibliotheque                       **
**  16/08/2003 (v0.1b) : premiere diffusion                                   **
*******************************************************************************/

// -----------------------
// Bibliothèques a inclure
// -----------------------
// --- Pas de bibliotheque ---

// --------------------------
// Déclaration des constantes
// --------------------------
string LMQ_PREFIXE="LMQ_";
string LMQ_CSUFFIX="_COUNT";

// -------------------------
// Prototypage des fonctions
// -------------------------
// --- Fonctions d'informations de base ---
int LMQ_IsChan(string sChanName);
int LMQ_IsChanCreator(object oPC, string sChanName);
int LMQ_IsChanMember(object oPC, string sChanName);
object LMQ_GetChanCreator(string sChanName);
object LMQ_GetChanMember(string sChanName, string sMember);
string LMQ_UserList(string sChanName);
// --- Fonctions d'actions primitives ---
int LMQ_AddToChannel(object oJoiner, string sChanName);
int LMQ_CreateChannel(object oCreator, string sChanName);
int LMQ_RemoveFromChannel(object oMember, string sChanName);
// --- Fonctions d'actions de haut niveau ---
int LMQ_JoinChannel(object oJoiner, string sChanName);
int LMQ_KickUser(string sChanName, string sUserName);
// --- Fonctions liees a la composition et la diffusion des messages ---
void LMQ_PushMessageOnChan(string sChanName, string sMessage, object oOwner=OBJECT_INVALID);
string LMQ_ComposeMessage(string sChanName, string sMessage, object oSender=OBJECT_INVALID);
void LMQ_SendMessage(object oDest, string sChanName, string sMessage, object oSender=OBJECT_INVALID);
// --- Fonctions liees au PNJ/Listener
void LMQ_CommandInterpretor(int nListenPN, object oOwner);
void LMQ_InitiateListener(object oListener);


// ------------------------
// Definition des fonctions
// ------------------------

/******************************************
* Fonction : LMQ_IsChan                   *
*-----------------------------------------*
* Cette fonction permet de savoir si le   *
* canal specifie existe                   *
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal a tester     *
*-----------------------------------------*
* Sortie :                                *
*   TRUE/FALSE indiquant si le canal exis-*
*   te ou non.                            *
*******************************************/
int LMQ_IsChan(string sChanName)
{
  // --- Recuperation du compteur suppose de membre du canal nomme ---
  int nCount=GetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
  if (nCount>0)
  {
    // -- Compte superieur a 0 signifiant qu'il y a au moins un membre, le canal existe --
    return TRUE;
  }
  else
  {
    // -- Compte egal a 0 signifiant que le compteur n'existe pas ou qu'il n'y a pas de membre, le canal n'existe pas  --
    return FALSE;
  }
}

/******************************************
* Fonction : LMQ_IsChanMember             *
*-----------------------------------------*
* Cette fonction permet de savoir si le   *
* membre specifie appartient au canal     *
*-----------------------------------------*
* Entree :                                *
*   oPC : le membre a tester              *
*   sChanName : nom du canal a tester     *
*-----------------------------------------*
* Sortie :                                *
*   TRUE/FALSE indiquant si le membre fait*
*   bien partie du canal                  *
*******************************************/
int LMQ_IsChanMember(object oPC, string sChanName)
{
  // --- Test si le canal existe ---
  if (LMQ_IsChan(sChanName))
  {
    // --- Recupere dans  la liste le membre qui porterait le meme nom ---
    object oMember=LMQ_GetChanMember(sChanName, GetName(oPC));
    // --- Test si cette recherche a ete fructueuse
    if (GetIsObjectValid(oMember))
    {
      // -- La cle CD et le nom de joueur sont-ils identiques ? --
      if ((GetPCPublicCDKey(oPC)==GetPCPublicCDKey(oMember)) && (GetPCPlayerName(oPC)==GetPCPlayerName(oMember)))
      {
        // -- C'est bien un membre de la liste du canal --
        return TRUE;
      }
      else
      {
        // -- Il n'est pas membre --
        return FALSE;
      }
    }
    else
    {
      // -- aucun membre ne porte le meme nom, celui la n'est donc pas membre --
      return FALSE;
    }
  }
  else
  {
    // -- Le canal n'existe pas, donc pas de membre --
    return FALSE;
  }
}

/******************************************
* Fonction : LMQ_IsChanCreator            *
*-----------------------------------------*
* Cette fonction permet de savoir si le   *
* membre specifie est le createur du canal*
*-----------------------------------------*
* Entree :                                *
*   oPC : le membre a tester              *
*   sChanName : nom du canal a tester     *
*-----------------------------------------*
* Sortie :                                *
*   TRUE/FALSE indiquant si le membre fait*
*   bien partie du canal                  *
*******************************************/
int LMQ_IsChanCreator(object oPC, string sChanName)
{
  // --- Test si le canal existe ---
  if (LMQ_IsChan(sChanName))
  {
    // --- Recupere le premier membre du canal ---
    object oMember=LMQ_GetChanCreator(sChanName);
    // -- La cle CD et le nom de joueur et le nom du personnage sont-ils identiques ? --
    if ((GetName(oPC)==GetName(oMember)) && (GetPCPublicCDKey(oPC)==GetPCPublicCDKey(oMember)) && (GetPCPlayerName(oPC)==GetPCPlayerName(oMember)))
    {
      // C'est le cas, ce premier membre identifie est donc bien le createur
      return TRUE;
    }
    else
    {
      // -- aucun membre ne porte le meme nom, celui la n'est donc pas membre --
      return FALSE;
    }
  }
  else
  {
    // -- Le canal n'existe pas, donc pas de membre --
    return FALSE;
  }
}

/******************************************
* Fonction : LMQ_GetChanMember            *
*-----------------------------------------*
* Cette fonction renvoie le premier membre*
* d'un canal dont le nom est identique a  *
* celui specifie                          *
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal a tester     *
*   sMember : nom du personnage a chercher*
*-----------------------------------------*
* Sortie :                                *
*   un objet representant le membre ou    *
*   OBJECT_INVALID                        *
*******************************************/
object LMQ_GetChanMember(string sChanName, string sMember)
{
  if (LMQ_IsChan(sChanName))
  {
    int nCount=GetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
    int bFound=FALSE;
    object oTmp;
    while ((nCount>0) && (!bFound))
    {
      oTmp=GetLocalObject(GetModule(), LMQ_PREFIXE+sChanName+IntToString(nCount));
      if (GetName(oTmp)==sMember)
      {
        bFound=TRUE;
      }
      else
      {
        nCount--;
      }
    }
    if (bFound)
    {
      return oTmp;
    }
    else
    {
      return OBJECT_INVALID;
    }
  }
  else
  {
    return OBJECT_INVALID;
  }
}

/******************************************
* Fonction : LMQ_GetChanCreator           *
*-----------------------------------------*
* Cette fonction renvoie le premier membre*
* d'un canal specifie                     *
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal a tester     *
*-----------------------------------------*
* Sortie :                                *
*   un objet representant le createur ou  *
*   OBJECT_INVALID pour le cas ou le canal*
*   n'existe pas. Un canal existant a tou-*
*   jours au moins un membre : le createur*
*******************************************/
object LMQ_GetChanCreator(string sChanName)
{
  if (LMQ_IsChan(sChanName))
  {
    return GetLocalObject(GetModule(), LMQ_PREFIXE+sChanName+"1");
  }
  else
  {
    return OBJECT_INVALID;
  }
}

/******************************************
* Fonction : LMQ_AddToChannel             *
*-----------------------------------------*
* Cette fonction ajoute la creature speci-*
* a la suite de la liste des membres du   *
* canal specifie                          *
*-----------------------------------------*
* Entree :                                *
*   oJoiner : creature a ajouter          *
*   sChanName : nom du canal cible        *
*-----------------------------------------*
* Sortie :                                *
*   toujours TRUE                         *
*******************************************/
int LMQ_AddToChannel(object oJoiner, string sChanName)
{
  int nCount=GetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
  nCount++;
  SetLocalObject(GetModule(), LMQ_PREFIXE+sChanName+IntToString(nCount), oJoiner);
  SetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX, nCount);
  return TRUE;
}

/******************************************
* Fonction : LMQ_CreateChannel            *
*-----------------------------------------*
* Cette fonction cree le premier membre   *
* d'un canal et le compteur associe       *
*-----------------------------------------*
* Entree :                                *
*   oCreator : membre createur            *
*   sChanName : nom du canal cible        *
*-----------------------------------------*
* Sortie :                                *
*   toujours TRUE                         *
*******************************************/
int LMQ_CreateChannel(object oCreator, string sChanName)
{
  object oModule=GetModule();
  SetLocalInt(oModule, LMQ_PREFIXE+sChanName+LMQ_CSUFFIX, 1);
  SetLocalObject(oModule, LMQ_PREFIXE+sChanName+"1", oCreator);
  return TRUE;
}

/******************************************
* Fonction : LMQ_RemoveFromChannel        *
*-----------------------------------------*
* Cette fonction supprime un membre speci-*
* fie du canal specifie                   *
*-----------------------------------------*
* Entree :                                *
*   oMember : membre a supprimer          *
*   sChanName : nom du canal cible        *
*-----------------------------------------*
* Sortie :                                *
*   renvoie TRUE si le membre est supprime*
*   sinon renvoie FALSE                   *
*******************************************/
int LMQ_RemoveFromChannel(object oMember, string sChanName)
{
  int nCount=GetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
  object oModule=GetModule();
  int nC;
  object oTmp;
  int bFound=FALSE;
  for (nC=1;nC<=nCount;nC++)
  {
    oTmp=GetLocalObject(oModule, LMQ_PREFIXE+sChanName+IntToString(nC));
    if (!bFound)
    {
      if ((GetName(oMember)==GetName(oTmp)) && (GetPCPlayerName(oMember)==GetPCPlayerName(oTmp)) && (GetPCPublicCDKey(oMember)==GetPCPublicCDKey(oTmp)))
      {
        bFound=TRUE;
      }
    }
    if (bFound)
    {
      if (nC<nCount)
      {
        SetLocalObject(oModule, LMQ_PREFIXE+sChanName+IntToString(nC), GetLocalObject(oModule, LMQ_PREFIXE+sChanName+IntToString(nC+1)));
      }
    }
  }
  if (bFound)
  {
    DeleteLocalObject(oModule, LMQ_PREFIXE+sChanName+IntToString(nCount));
    nCount--;
    if (nCount>0)
    {
      SetLocalInt(oModule, LMQ_PREFIXE+sChanName+LMQ_CSUFFIX, nCount);
    }
    else
    {
      DeleteLocalInt(oModule, LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
    }
    return TRUE;
  }
  else
  {
    return FALSE;
  }
}


/******************************************
* Fonction : LMQ_JoinChannel              *
*-----------------------------------------*
* Cette fonction se charge d'ajouter un   *
* membre a un canal apres quelques test   *
* prealable                               *
*-----------------------------------------*
* Entree :                                *
*   oJoiner : creature a ajouter          *
*   sChanName : nom du canal cible        *
*-----------------------------------------*
* Sortie :                                *
*   TRUE si le membre est ajoute          *
*   FALSE dans les autres cas             *
*******************************************/
int LMQ_JoinChannel(object oJoiner, string sChanName)
{
  if (GetIsPC(oJoiner))
  {
    if (LMQ_IsChan(sChanName))
    {
      if (!LMQ_IsChanMember(oJoiner, sChanName))
      {
        return LMQ_AddToChannel(oJoiner, sChanName);
      }
      else
      {
        return FALSE;
      }
    }
    else
    {
      return FALSE;
    }
  }
  else
  {
    return FALSE;
  }
}

/******************************************
* Fonction : LMQ_KickUser                 *
*-----------------------------------------*
* Cette fonction kick un utilisateur de la*
* liste des membres du canal specifie     *
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal cible        *
*   sUserName : nom du membre             *
*-----------------------------------------*
* Sortie :                                *
*   TRUE si le membre est kicke           *
*   FALSE dans les autres cas             *
*******************************************/
int LMQ_KickUser(string sChanName, string sUserName)
{
  object oMember=LMQ_GetChanMember(sChanName, sUserName);
  if (GetIsPC(oMember))
  {
    return LMQ_RemoveFromChannel(oMember, sChanName);
  }
  else
  {
    return FALSE;
  }
}

/******************************************
* Fonction : LMQ_UserList                 *
*-----------------------------------------*
* Cette fonction cree un message compor-  *
* tant la liste des membres du canal donne*
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal cible        *
*-----------------------------------------*
* Sortie :                                *
*   chaine de caractere contenant la liste*
*   des membres                           *
*******************************************/
string LMQ_UserList(string sChanName)
{
  string sTmp="";
  object oMember;
  object oModule=GetModule();
  int nCount=GetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
  int nC;
  for (nC=1;nC<=nCount;nC++)
  {
    oMember=GetLocalObject(oModule, LMQ_PREFIXE+sChanName+IntToString(nC));
    sTmp=sTmp+GetName(oMember);
    if (nC==1)
    {
      sTmp=sTmp+"*";
    }
    if (nC<nCount)
    {
      sTmp=sTmp+", ";
    }
  }
  return sTmp;
}


/******************************************
* Fonction : LMQ_PutMessageOnChan         *
*-----------------------------------------*
* Cette fonction distribue un message a   *
* tous les membres d'un canal             *
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal cible        *
*   sMessage : contenu du message         *
*   oOwner : envoyeur du message          *
*-----------------------------------------*
* Si le oOwner est omis, le message sera  *
* considere comme un message systeme      *
*******************************************/
void LMQ_PushMessageOnChan(string sChanName, string sMessage, object oOwner=OBJECT_INVALID)
{
  object oTmp;
  int nCount=GetLocalInt(GetModule(), LMQ_PREFIXE+sChanName+LMQ_CSUFFIX);
  string sToSend=LMQ_ComposeMessage(sChanName, sMessage, oOwner);
  while (nCount>0)
  {
    oTmp=GetLocalObject(GetModule(), LMQ_PREFIXE+sChanName+IntToString(nCount));
    if (GetIsPC(oTmp))
    {
      SendMessageToPC(oTmp, sToSend);
    }
    nCount--;
  }
}

/******************************************
* Fonction : LMQ_ComposeMessage           *
*-----------------------------------------*
* Cette fonction compose un message pour  *
* envoie sur un canal donne. Elle se char-*
* ge egalement de composer les messages   *
* d'erreur ou les messages automatiques   *
* du systeme                              *
*-----------------------------------------*
* Entree :                                *
*   sChanName : nom du canal cible        *
*   sMessage : contenu du message         *
*   oSender : envoyeur du message         *
*-----------------------------------------*
* Sortie :                                *
*   La chaine complete du message         *
*-----------------------------------------*
* Si oSender est invalide, le message est *
*  automatiquement de type "systeme"      *
* "!OK" est le nom de canal a employer    *
*  pour creer un message individuel d'in- *
*  formation.                             *
* "!KO" est le nom de canal a employer    *
*  pour creer un message individuel d'er- *
*  reur                                   *
*******************************************/
string LMQ_ComposeMessage(string sChanName, string sMessage, object oSender=OBJECT_INVALID)
{
  string sHeader;
  string sToSend;
  if (sChanName=="!OK")
  {
    sHeader+=">> ";
  }
  else if (sChanName=="!KO")
  {
    sHeader+="!! ";
  }
  else
  {
    if (GetIsObjectValid(oSender))
    {
      sHeader="["+sChanName+" : "+GetName(oSender)+"] ";
    }
    else
    {
      sHeader="["+sChanName+"]";
    }
  }
  if (GetIsObjectValid(oSender))
  {
    sToSend=sHeader+sMessage;
  }
  else
  {
    sToSend=sHeader+"<"+sMessage+">";
  }
  return sToSend;
}

/******************************************
* Fonction : LMQ_SendMessage              *
*-----------------------------------------*
* Cette fonction envoie un message a un   *
* unique destinataire                     *
*-----------------------------------------*
* Entree :                                *
*   oDest : le destinataire du message    *
*   sChanName : nom du canal relatif      *
*   sMessage : contenu du message         *
*   oOwner : envoyeur du message          *
*-----------------------------------------*
* Si le oOwner est omis, le message sera  *
* considere comme un message systeme      *
*******************************************/
void LMQ_SendMessage(object oDest, string sChanName, string sMessage, object oSender=OBJECT_INVALID)
{
  string sToSend=LMQ_ComposeMessage(sChanName, sMessage, oSender);
  SendMessageToPC(oDest, sToSend);
}

/******************************************
* Fonction : LMQ_CommandInterpretor       *
*-----------------------------------------*
* Cette fonction gere les Patterns captes *
* par le listener et execute les commandes*
* correspondante                          *
*-----------------------------------------*
* Entree :                                *
*   nListenPN : numero de pattern capte   *
*   oOwner : proprietaire du Listener     *
*******************************************/
void LMQ_CommandInterpretor(int nListenPN, object oOwner)
{
  switch (nListenPN)
  {
    case 3000 : // --- Envoie d'un message ---
    {
      string sChanName=GetMatchedSubstring(1);
      if (LMQ_IsChan(sChanName))
      {
        if (LMQ_IsChanMember(oOwner, sChanName))
        {
          string sMessage=GetMatchedSubstring(3);
          LMQ_PushMessageOnChan(sChanName, sMessage, oOwner);
        }
        else
        {
          LMQ_SendMessage(oOwner, "!KO", "Vous n'etes pas membre de ce canal");
        }
      }
      else
      {
        LMQ_SendMessage(oOwner, "!KO", "Le canal n'existe pas");
      }
    }break;
    case 3001 : // --- Creation d'un canal ---
    {
      string sChanName=GetMatchedSubstring(2);
      if (LMQ_IsChan(sChanName))
      {
        LMQ_SendMessage(oOwner, "!KO", "Le canal existe deja");
      }
      else
      {
        LMQ_CreateChannel(oOwner, sChanName);
        LMQ_SendMessage(oOwner, "!OK", "Canal '" + sChanName + "' cree");
      }
    }break;
    case 3002 : // --- Se joindre a un canal ---
    {
      string sChanName=GetMatchedSubstring(2);
      if (!LMQ_IsChan(sChanName))
      {
        LMQ_SendMessage(oOwner, "!KO", "Le canal n'existe pas");
      }
      else
      {
        if (LMQ_JoinChannel(oOwner, sChanName))
        {
          LMQ_SendMessage(oOwner, "!OK", "Vous rejoignez le canal '" + sChanName + "'");
          LMQ_PushMessageOnChan(sChanName, "L'utilisateur '"+GetName(oOwner)+"' a rejoins le canal");
        }
        else
        {
          LMQ_SendMessage(oOwner, "!KO", "Vous n'avez pas reussi a joindre le canal '" + sChanName + "'");
        }
      }
    }break;
    case 3003 : // --- Kicker un user d'un canal ---
    {
      string sChanName=GetMatchedSubstring(6);
      if (!LMQ_IsChan(sChanName))
      {
        LMQ_SendMessage(oOwner, "!KO", "Le canal n'existe pas");
      }
      else
      {
        if (LMQ_IsChanCreator(oOwner, sChanName))
        {
          string sUserName=GetMatchedSubstring(3);
          if (LMQ_KickUser(sChanName, sUserName))
          {
            LMQ_PushMessageOnChan(sChanName, "L'utilisateur '"+sUserName+"' a ete kicke du canal");
          }
          else
          {
            LMQ_SendMessage(oOwner, "!KO", "Impossible de banir l'utilisateur '"+sUserName+"'");
          }
        }
        else
        {
          LMQ_SendMessage(oOwner, "!KO", "Vous n'avez pas le droit de kicker sur ce canal");
        }
      }
    }break;
    case 3004 : // --- Quitter un canal ---
    {
      string sChanName=GetMatchedSubstring(2);
      if (!LMQ_IsChan(sChanName))
      {
        LMQ_SendMessage(oOwner, "!KO", "Le canal n'existe pas");
      }
      else
      {
        if (LMQ_RemoveFromChannel(oOwner, sChanName))
        {
          LMQ_PushMessageOnChan(sChanName, "L'utilisateur '"+GetName(oOwner)+"' a quitte le canal");
          LMQ_SendMessage(oOwner, "!OK", "Vous avez quitte le canal'"+sChanName+"'");
        }
        else
        {
          LMQ_SendMessage(oOwner, "!KO", "Vous n'avez pas reussi a quitte le canal'"+sChanName+"'");
        }
      }
    }break;
    case 3005 : // --- Lister les membres d'un canal ---
    {
      string sChanName=GetMatchedSubstring(2);
      if (!LMQ_IsChan(sChanName))
      {
        LMQ_SendMessage(oOwner, "!KO", "Le canal n'existe pas");
      }
      else
      {
        if (LMQ_IsChanMember(oOwner, sChanName))
        {
          string sList=LMQ_UserList(sChanName);
          LMQ_SendMessage(oOwner, "!OK", "Liste des membres du canal '"+sChanName+"' : "+sList);
        }
        else
        {
          LMQ_SendMessage(oOwner, "!KO", "Vous n'avez pas le droit de lister ce canal, vous n'en etes pas membre");
        }
      }
    }break;
  }
}

/******************************************
* Fonction : LMQ_InitiateListener         *
*-----------------------------------------*
* Cette fonction initialise la liste des  *
* Patterns captes par le Listener donne   *
*-----------------------------------------*
* Entree :                                *
*   oListener : le Listener               *
*******************************************/
void LMQ_InitiateListener(object oListener)
{
  SetListenPattern(oListener, "!***w**", 3000);
  SetListenPattern(oListener, "?cchan*w**", 3001);
  SetListenPattern(oListener, "?jchan*w**", 3002);
  SetListenPattern(oListener, "?kchan*w'**'*w**", 3003);
  SetListenPattern(oListener, "?qchan*w**", 3004);
  SetListenPattern(oListener, "?lchan*w**", 3005);
}

// --- Commenter pour la compilation dfinitive
//void main() {}

      object oListener=CreateObject(OBJECT_TYPE_CREATURE, "ecouteur", GetLocation(oObj)); // -- Creation du Listener --
      SetLocalObject(oListener, "MYPC", oObj); // -- Etablissement du lien Listener-PC --
      SetLocalObject(oObj, "MYLISTENER", oListener); // -- Etablissement du lien PC-Listener --
      AssignCommand(oListener, ActionForceFollowObject(oObj, 5.0)); // -- Passer en mode ForceFollow --

#include "lib_lrvmessqueue"

void main()
{
  LMQ_InitiateListener(OBJECT_SELF); // -- Initialisation des patterns d'ecoute --
  SetListening(OBJECT_SELF, TRUE); // -- Activation du mode d'ecoute --
}

#include "lib_lrvmessqueue"

void main()
{
  object oSpeaker=GetLastSpeaker(); // -- Recupere la derniere creature entendue --
  if (GetIsPC(oSpeaker)) // -- verifie qu'il s'agit d'un PC --
  {
    object oOwner=GetLocalObject(OBJECT_SELF, "MYPC");
    if (GetPCPublicCDKey(oOwner)==GetPCPublicCDKey(oSpeaker)) // -- verifie qu'il s'agit de SON PC --
    {
      int nLP=GetListenPatternNumber(); // -- recupere le numero de pattern capte --
      LMQ_CommandInterpretor(nLP, oSpeaker); // -- transmet l'info au central de commande --
    }
  }
}

void main()
{
  object oPC=GetEnteringObject();
  if (GetIsPC(oPC))
  {
    SetLocalInt(oPC, "FIRST", TRUE);
  }
}

void main()
{
  object oObj=GetEnteringObject();
  if (GetIsPC(oObj))
  {
    if (GetLocalInt(oObj, "FIRST"))
    {
      DeleteLocalInt(oObj, "FIRST");
      object oListener=CreateObject(OBJECT_TYPE_CREATURE, "ecouteur", GetLocation(oObj)); // -- Creation du Listener --
      SetLocalObject(oListener, "MYPC", oObj); // -- Etablissement du lien Listener-PC --
      SetLocalObject(oObj, "MYLISTENER", oListener); // -- Etablissement du lien PC-Listener --
      AssignCommand(oListener, ActionForceFollowObject(oObj, 5.0)); // -- Passer en mode ForceFollow --
    }
  }
}