//:: ly_lib_time.nss
int ly_day()
{
    int iCTY = GetCalendarYear() ;
    int iCTM = GetCalendarMonth() ;
    int iCTD = GetCalendarDay() ;
    int iCDay = iCTY*12*28 + iCTM*28 + iCTD ;
    return iCDay ;
}

int ly_time()
{
    // Bug Minutes & Secondes ...
    // 3 minutes/heures => 1h RP <=> 180 sec IRL
    int iTH = GetTimeHour();
    int iTM = GetTimeMinute();
    int iTS = GetTimeSecond();
    int iCTime = FloatToInt(HoursToSeconds(iTH)) + iTM*60 + iTS ;
    return iCTime ;
}

void ly_grant_rest(object oPC)
{
//
// Init du repos et mort
    SetLocalInt(oPC, "PC_LastRest", ly_time()-540);
    SetLocalInt(oPC, "PC_LastDayRest", ly_day());
    SetLocalInt(oPC, "DyingHP", -1);
    SendMessageToPC(oPC, "Vous pouvez vous reposer pour recuperer." ) ;
}

void ly_anti_deco(object oPC) {
  if (!GetIsDM (oPC)) {
  // don't let players to cheat deco/reco
      talent tFeat, tSpell;
      int nIndex, i, nTalentID;
      for (nIndex=1; nIndex<1000; nIndex++) {
        tFeat = TalentFeat (nIndex);
        tSpell = TalentSpell(nIndex);
        if (GetIsTalentValid(tFeat)) {
            nTalentID = GetIdFromTalent(tFeat);
            for (i=1; i<40; i++) {
              DecrementRemainingFeatUses(oPC, nTalentID);
              if (!GetHasFeat(nTalentID, oPC)) i = 40;
            }
        }
        if (GetIsTalentValid(tSpell)) {
            nTalentID = GetIdFromTalent(tSpell);
            for (i=1; i<40; i++) {
              DecrementRemainingSpellUses(oPC, nTalentID);
              if (!GetHasSpell(nTalentID, oPC)) i = 40;
            }
        }
      }
      SendMessageToPC(oPC, "Sorts et Dons desactives : vous devez vous reposez pour recuperer." ) ;
  // end cheating section
  }
}

// void main() {}

//:: ly_lib_death.nss
//:: ////////////////////////////
//:: // update lylver 2005-04-03
//:: // optimisation de code dans les
//:: // recherches d'objets par Tag
//:: // externalisation de la commande DestroyObject
//:: // dans une sous-fonction pour effet effectif en retour de l'appel
//:: // tsss sale bug
//:: ////////////////////////////

int MustHaveNoItem(object oPC, string sObjectTag) {
  int iNbItem=0;
  object oItem = GetFirstItemInInventory(oPC);
  while( GetIsObjectValid(oItem) ){
      if( GetTag(oItem) == sObjectTag ){
        iNbItem += GetNumStackedItems(oItem);
        DestroyObject(oItem);
      }
      oItem = GetNextItemInInventory(oPC);
  }
  return iNbItem;
}

void CleanDeathCard(object oDead) { // wrapper
// Gestion des cartes de mort
  if( GetItemPossessedBy(oDead, "mortNODROP") != OBJECT_INVALID ){
      MustHaveNoItem(oDead,"mortNODROP");
  }
}
// end carte mort

void CleanAgoCard(object oDead) {
// Gestion des cartes d'agonie
  if( GetItemPossessedBy(oDead, "agoNODROP") != OBJECT_INVALID ){
      MustHaveNoItem(oDead,"agoNODROP");
  }
}
// end carte agonie

void GiveDeathCard(object oPC) {
  // donne une carte de mort pour la deco et une variable d'etat
  string sCarte = "mortNODROP", sRef = "mortnodrop" ;
  if( GetItemPossessedBy(oPC, sCarte) == OBJECT_INVALID )
      CreateItemOnObject(sRef, oPC, 1);
}

void GiveAgoCard(object oPC) {
  // donne une carte d'agonie pour la deco et une variable d'etat
  string sCarte = "agoNODROP", sRef = "agonodrop" ;
  if( GetItemPossessedBy(oPC, sCarte) == OBJECT_INVALID )
      CreateItemOnObject(sRef, oPC, 1);
}

int ChkDeathCard(object oPC) {
// Gestion des cartes de mort
  int nCard = 0 ;
  if( GetItemPossessedBy(oPC, "mortNODROP") != OBJECT_INVALID ){
      nCard = MustHaveNoItem(oPC,"mortNODROP");
  }
  if( nCard>0 ) ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectDeath(),oPC);
// end carte mort
  return nCard ;
}

int ChkAgoCard(object oPC) {
// Gestion des cartes d'agonie
  int nCard = 0 ;
  if( GetItemPossessedBy(oPC, "agoNODROP") != OBJECT_INVALID ){
      nCard = MustHaveNoItem(oPC,"agoNODROP");
  }
  if( nCard>0 ){
  ApplyEffectToObject(DURATION_TYPE_TEMPORARY,EffectMovementSpeedDecrease(75),oPC,60.0);
  ApplyEffectToObject(DURATION_TYPE_PERMANENT,EffectAbilityDecrease(ABILITY_CONSTITUTION, 1),oPC);
  }
// end carte agonie
  return nCard ;
}

void ChkAgoSpeed(object oPC) {
// Gestion des cartes d'agonie
  if( GetItemPossessedBy(oPC, "agoNODROP") != OBJECT_INVALID ){
  ApplyEffectToObject(DURATION_TYPE_TEMPORARY,EffectMovementSpeedDecrease(75),oPC,60.0);
  }
// end carte agonie
}

// void main(){}

//:: tn_mod_o0_dying.nss
//:: ////////////////////////////// /////////////////
//:: Lylver 2004-12-15
//:: pour SoW : agonie
//:: ////////////////////////////// /////////////////
//:: Dying Script
//:: NW_O0_DEATH.NSS
//:: Copyright (c) 2001 Bioware Corp.
//:: ////////////////////////////// ////////////////
/*
    This script handles the default behavior
    that occurs when a player is dying.
    DEFAULT CAMPAIGN: player dies automatically
*/
//:///////////////////////// ////////////////////
//:: Created By: Brent Knowles
//:: Created On: November 6, 2001
//:///////////////////////// ////////////////////
//:: Updated On: 2004-04_19
//:: Updated By : Lylver
//:: Based on Henson Gallian Asmodee
//:: Player agonies
//
//#include "ly_aps_include"
//:: Update : 2005-01-24 : Lylver

#include "nw_i0_spells"
#include "ly_lib_death"

//Nombre de PV perdus par round
int nAgonie = 1;
// Seuil Bas avant de mourrir
int nDEATHDOOR = -9;
//Delai en secondes entre la perte de PV (6.0 = 1 round)
float fDelai = 6.0;
//DC du Jet de Vigueur permettant de se stabiliser
int nDCFort = 13;
//% de chance d'etre stabilise (entre 1 et 10; 10=100%)
int nStab = 1;

void LoopDying(object oDying) {
// divers tests : grop coup =&gt; si suis deja dans le script de mort : retour
  if( GetLocalInt(oDying,"BLOKE_PC_MORT") == 1 ){
      // SendMessageToPC(oDying, "Exit Agonie : BLOKE_PC_MORT=1");
      return ;
  }
// si je suis deja passe par OnDeath annule et retour
  if( GetLocalInt(oDying,"BLOKE_PC_AGO")==2 ){
      // SendMessageToPC(oDying, "Exit Agonie : BLOKE_PC_AGO=2");
      return ;
  }
/* eventuellement restore les PVs perdus dus a la bataille qui continue */
/* considerant agonie independante des dommages */
/* possibilite de KO */
  int nPv=0 ; // compteur independant des fluctuations
  int CurHP = GetCurrentHitPoints(oDying);
  int DyingHP = GetLocalInt(oDying, "DyingHP");
  int nBonusCon = GetAbilityModifier(ABILITY_CONSTITUTION, oDying);
  int bAgo = (GetLocalInt(oDying,"BLOKE_PC_AGO")==1) ? TRUE : FALSE ;
// maj compteur independant des fluctuations
  if (CurHP<=0) nPv = DyingHP; else nPv=CurHP;
// statut calcule
// reprise du cours normal de l'agonie : agonie ou mort
  if( bAgo ){
      // SendMessageToPC(oDying, "Boucle Agonie : Test Pvs");
      if( nPv>=nDEATHDOOR ){
        FloatingTextStringOnCreature("Agonisant" ,oDying);
      } else { // nPv&lt;nDEATHDOOR
  // Test si on depasse l'endurance du PJ
        effect eMort = EffectDeath(FALSE, FALSE);
        SpeakString("Vous etes mort.");
        // Remise a zero pour mort future
        SetLocalInt(oDying,"DyingHP", -1);
        DeleteLocalInt(oDying,"BLOKE_PC_AGO");
        ApplyEffectToObject(DURATION_TYPE_INSTANT, eMort, oDying);
        return;
      }
  } else { // (!bAgo)
// Reprise de la conscience : stabilise et positif
      // SendMessageToPC(oDying, "Fin Agonie : Mise au minimum a 1 Pv");
      if( nPv >= 0 ){
      // Remise a zero pour mort future
        DeleteLocalInt(oDying,"DyingHP");
        DeleteLocalInt(oDying,"BLOKE_PC_AGO");
        SendMessageToPC(oDying, "Vous etes sauf.") ;
        if (CurHP<=0) {
            effect eStabilise = EffectHeal(1-GetCurrentHitPoints(oDying));
            ApplyEffectToObject(DURATION_TYPE_INSTANT, eStabilise, oDying);
        }
        PlayVoiceChat(VOICE_CHAT_LAUGH, oDying);
        AssignCommand(oDying, ClearAllActions());
      // Gestion des cartes de mort
        CleanDeathCard(oDying);
        ChkAgoSpeed(oDying) ;
      // end carte mort
  // pas sur avoir besoin
        effect eRaise = EffectResurrection() ;
        ApplyEffectToObject(DURATION_TYPE_INSTANT, eRaise, oDying);
        return;
      } else { // nPv &lt; 0
        // nouvelle blessure reblocage (effet saignement ?)
        SetLocalInt(oDying,"BLOKE_PC_AGO",1);
        SendMessageToAllDMs("Cas d'agonie bizarre : ajuste") ;
      }
  }
// perte ou stable ?
  nAgonie = (nPv<0) ? 1 : 0 ;
  // SendMessageToPC(oDying, "Boucle Agonie : perte ou non de Pvs");
  // mise a jour : perte ou stable
  SetLocalInt(oDying,"DyingHP",nPv-nAgonie);
// KO ou en train de mourir, test de recuperation
  // JS Fortitude
  int nStvig = FortitudeSave(oDying, nDCFort,SAVING_THROW_TYPE_DIVINE);
  int nChanceStab;
  switch(nStvig) {
      case 0:
        nChanceStab = 11; // Aucune chance si JS Fortitude rate
      break;
      case 1:
        nChanceStab = d10(1);
      break;
      case 2:
        nChanceStab = 0; // Immortel
      break;
      default:
        nChanceStab = 11;
      break;
  }
//
// deux cas de sortie : chance ou soins exterieurs
//
  // SendMessageToPC(oDying, "Boucle Agonie : possibilite de retour a la conscience.");
  if (nChanceStab <= nStab) { // chance : ramene a 0 : attendre encore 6 secondes de KO
      if (nPv<0) SendMessageToPC(oDying, "Vous luttez pour survivre");
      else SendMessageToPC(oDying, "Vous reprenez connaissance."); // parfois debout avant le message
      SetLocalInt(oDying,"BLOKE_PC_AGO",0);
      SetLocalInt(oDying,"DyingHP",0);
      if (CurHP<0) {
        effect eStabilise = EffectHeal(-CurHP);
        ApplyEffectToObject(DURATION_TYPE_INSTANT, eStabilise, oDying); // reste a 0 KO
      } else ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectKnockdown(), oDying,5.9);
      // force le KO qq secondes
      // La mort s'eloigne
  } else {
      if (nPv<0) {
        SendMessageToPC(oDying, "La mort approche.");
        if (d3() == 1) PlayVoiceChat(VOICE_CHAT_NEARDEATH, oDying);
      } else { // soins exterieurs
//        SendMessageToPC(oDying, "Le dernier choc vous fait encore mal.");
      // Remise a zero pour mort future
        SetLocalInt(oDying,"DyingHP", 0);
        SetLocalInt(oDying,"BLOKE_PC_AGO",0);
        ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectKnockdown(), oDying,5.9);
      }
  }
  DelayCommand(fDelai, LoopDying(oDying));
}

void CheckDying(object oDying) {
// si suis deja dans le script : retour
  if (GetLocalInt(oDying,"BLOKE_PC_AGO")!=0) return ;
// marqueur d'entree dans le script
  SetLocalInt(oDying,"BLOKE_PC_AGO",1);
  GiveAgoCard(oDying) ;
  // Initialisation temps d'agonie : de -1 a -9
  SetLocalInt(oDying,"DyingHP", -1);
// divers tests : gros coup =&gt; si suis deja dans le script de mort : retour
  if( GetLocalInt(oDying,"BLOKE_PC_MORT") == 1 ){
      // SendMessageToPC(oDying, "Test Agonie : de script de mort deja execute");
      return ;
  }
// au cas ou Pv&lt;=-10 le script OnPlayerDeath gere normalement
// mais les deux scripts peuvent etre legerement decales : on renvoie la-bas
  if (GetCurrentHitPoints(oDying) <= -10) {
      //donne une carte de mort
      FloatingTextStringOnCreature("Mort", oDying) ;
      ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectDeath(FALSE,FALSE), oDying);
      return ;
  }
// contre les gens qui deco en ago
  GiveDeathCard(oDying) ;
//  ChkAgoCard(oDying) ; oups... -1 constit ca tue
//
  PlayVoiceChat(VOICE_CHAT_HEALME, oDying);
//  AssignCommand(oDying, ClearAllActions());
  AssignCommand(GetLastDamager(oDying), ClearAllActions(TRUE));
  ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectEthereal(), oDying, fDelai);
// agonie
  DelayCommand(fDelai, LoopDying(oDying));
}

void main()
{
  object oDying = GetLastPlayerDying();
  // desynchroniser dying et death
  DelayCommand(2.0,CheckDying(oDying)) ;
  RemoveSpecificEffect(EFFECT_TYPE_POLYMORPH,oDying) ;
}

//:: tn_mod_o0_death.nss
//:: ////////////////////////////// /////////////////
//:: Lylver 2005-01-08
//:: modification de la remise a neutre des reputations
//:: envers les factions
//:: probleme possible de reputation personnelle
//:: ////////////////////////////// /////////////////
//:: Lylver 2004-12-15
//:: pour SoW : agonie
//:: ////////////////////////////// /////////////////
//:: Death Script
//:: NW_O0_DEATH.NSS
//:: Copyright (c) 2001 Bioware Corp.
//:: ////////////////////////////// ////////////////
/*
    This script handles the default behavior
    that occurs when a player dies.

    BK: October 8 2002: Overriden for Expansion
*/
//:///////////////////////// ////////////////////
//:: Created By: Brent Knowles
//:: Created On: November 6, 2001
//:///////////////////////// ////////////////////
#include "ly_lib_death"

void main()
{
  object oDead = GetLastPlayerDied();
  location lDead = GetLocation(oDead) ;
  object oKiller = GetLastKiller();
  // marqueur d'entree dans le script
  if( GetCurrentHitPoints(oDead) <= -10 ){
      SetLocalInt(oDead,"BLOKE_PC_MORT",1);
      // SendMessageToPC(oDead, "OnDeath Pv&lt;=-10 : dead");
  } else {
      SendMessageToPC(oDead, "OnDeath Event Bogus : exiting");
      DeleteLocalInt(oDead,"BLOKE_PC_MORT");
      return ;
  }
  // si on est dans la boucle d'agonie, mettre un flag pour forcer la sortie
  // ou empecher son deroulement
  SetLocalInt(oDead,"BLOKE_PC_AGO",2);
  // donne une carte de mort pour la deco et une variable d'etat
  GiveDeathCard(oDead) ;
  // * make friendly to Each of the 3 common factions
//  AssignCommand(oDead, ClearAllActions());
  // * Note: waiting for Sophia to make SetStandardFactionReptuation to clear all personal reputation
  // Lylver : modification de reputation personnelle a faire le cas echeant.
  if (GetStandardFactionReputation(STANDARD_FACTION_COMMONER, oDead) < 50)
  { SetStandardFactionReputation(STANDARD_FACTION_COMMONER, 50, oDead);
  }
  if (GetStandardFactionReputation(STANDARD_FACTION_MERCHANT, oDead) < 50)
  { SetStandardFactionReputation(STANDARD_FACTION_MERCHANT, 50, oDead);
  }
  if (GetStandardFactionReputation(STANDARD_FACTION_DEFENDER, oDead) < 50)
  { SetStandardFactionReputation(STANDARD_FACTION_DEFENDER, 50, oDead);
  }
  ClearPersonalReputation(oDead,oKiller) ; // permanent en cas de mort
  ClearPersonalReputation(oKiller,oDead) ; // simultanee et respawn
      // ceux qui ont vu le deces perdent leur inimitie personnelle
      // envers le mort, l'amitie reste.
  object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, 40.0f, lDead);
  while (GetIsObjectValid(oTarget)) {
      if(!GetIsReactionTypeFriendly(oTarget)) {
        ClearPersonalReputation(oDead,oTarget) ;
        ClearPersonalReputation(oTarget,oDead) ;
      }
      // creature suivante dans un rayon de 4 tiles
      oTarget = GetNextObjectInShape(SHAPE_SPHERE, 40.0f, lDead);
  }
  DelayCommand(2.5, PopUpGUIPanel(oDead,GUI_PANEL_PLAYER_DEATH));
}

//:: tn_mod_o0_respaw.nss
//:: ////////////////////////////// /////////////////
//:: Generic On Pressed Respawn Button
//:: Copyright (c) 2001 Bioware Corp.
//:: ////////////////////////////// ////////////////
/*
// * June 1: moved RestoreEffects into plot include
*/
//:: ////////////////////////////// ////////////////
//:: Created By:  Brent
//:: Created On:  November
//:///////////////////////// ////////////////////
#include "nw_i0_plot"
#include "ly_lib_time"
void main()
{
    object oRespawner = GetLastRespawnButtonPresser();
    ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectResurrection(),oRespawner);
    ApplyEffectToObject(DURATION_TYPE_INSTANT,EffectHeal(GetMaxHitPoints(oRespawner)), oRespawner);
    RemoveEffects(oRespawner);
    //* Return PC to temple
    // * destroy death item : mort
    // * Applies an XP and GP penalty to level &gt;3
    // * to the player respawning

    DestroyObject( GetItemPossessedBy(oRespawner,"mortNODROP"));
    DeleteLocalInt(oRespawner,"BLOKE_PC_MORT");
    DeleteLocalInt(oRespawner,"BLOKE_PC_AGO");

if ( GetHitDice(oRespawner)!= 1 )
    {
        int nXP = GetXP(oRespawner);
        int nLvl ;
        int nPenalty = 50 * GetHitDice(oRespawner);
        int nHD = GetHitDice(oRespawner);
        // total level
        // * 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;
            }
        nLvl=GetHitDice(oRespawner);
//        SendMessageToPC(oRespawner,&qu ot;Vous etes lvl " + IntToString(nLvl));
        if(nLvl>3)
        {
            SetXP(oRespawner, nNewXP);
            int nGoldToTake = FloatToInt(0.10 * GetGold(oRespawner));
            // * a cap of 10 000gp taken from you
            if (nGoldToTake > 50000)
            {
                nGoldToTake = 50000;
            }
            AssignCommand(oRespawner, TakeGoldFromCreature(nGoldToTake, oRespawner, TRUE));
            DelayCommand(4.0, FloatingTextStrRefOnCreature(58299, oRespawner, FALSE));
            DelayCommand(4.8, FloatingTextStrRefOnCreature(58300, oRespawner, FALSE));
        }
    }



    object oSpawnPoint = GetObjectByTag("NW_DEATH_TEMPLE");
    AssignCommand(oRespawner,JumpToLocation(GetLocation(oSpawnPoint)));
    ly_grant_rest(oRespawner) ;
}