View Full Version: Gump de Classe et Race

RunUO.FR Support > System > Gump de Classe et Race


Title: Gump de Classe et Race


Vortal - September 27, 2004 06:27 AM (GMT)
Je sait qu'il en existe plusieurs, mais aucun ne me convenait alors j'ai fait le mien. Le code n'est certainement pas optimisé, alors n'hésitez pas à le modifier à votre comvenance ! Mais faites moi part des différentes amélioration que vous aurez pu y apporter.

J'ai mis 3 races de base (nain, elfe et humain) ainsi que 3 classes de base (guerrier, mage et artisan) mais il est facile d'en ajouter ou d'en supprimer.

Scripts\Custom\CharCreation.cs
CODE
using System;
using Server;
using Server.Gumps;
using Server.Targeting;
using Server.Mobiles;
using Server.Network;
using Server.Scripts.Commands;
using Server.Items;
using Scripts.CharCreationGump;

namespace Server.Scripts.Commands
{
public class CharCreationCommand
{
 public static void Initialize()
 {
  Server.Commands.Register( "CharCreation", AccessLevel.GameMaster, new CommandEventHandler(CharCreation_OnCommand ) );
 }

 [Usage( "CharCreation" )]
 [Description( "Permet de choisir sa race et sa classe" )]
 public static void CharCreation_OnCommand( CommandEventArgs e )
 {
  Mobile from = e.Mobile;
  from.SendGump( new CharCreationGump () );
 }
}
}

namespace Scripts.CharCreationGump
{
public class CharCreationGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public CharCreationGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );
  this.AddLabel( 20, 15, 1149, "Races" );
  this.AddLabel( 20, 45, 255, string.Format( "Il vous faut choisir une race pour votre personnage." ));

  this.AddButton( 20, 67, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 65, 255, string.Format( "Humain" ));
  this.AddButton( 20, 87, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 85, 255, string.Format( "Elfe" ));
  this.AddButton( 20, 107, 0x2623, 0x2622, 3, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 105, 255, string.Format( "Nain" ));

  this.AddLabel( 20, 145, 1149, string.Format( "Notez bien que chaque race possède ses propres avantages" ));
  this.AddLabel( 20, 160, 1149, string.Format( "et inconvénients. Ceux-ci sont énumérés dans les pages" ));
  this.AddLabel( 20, 175, 1149, string.Format( "suivantes avec une courte description." ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;

  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new HumainGump() );
    break;
   }
   case 2:
   {
    m.SendGump( new ElfeGump() );
    break;
   }
   case 3:
   {
    m.SendGump( new NainGump() );
    break;
   }
  }
 }
}

public class HumainGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public HumainGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Humain" );
  this.AddLabel( 20, 45, 255, string.Format( "La race humaine est la plus répandue et ne possède aucune" ));
  this.AddLabel( 20, 60, 255, string.Format( "limitation dans les classes. Ils sont en bons termes tant" ));
  this.AddLabel( 20, 75, 255, string.Format( "avec les elfes qu'avec les nains." ));

  this.AddLabel( 20, 105, 1149, string.Format( "Attributs de départ" ));
  this.AddLabel( 20, 135, 255, string.Format( "Force : {0}", "30" ));
  this.AddLabel( 20, 150, 255, string.Format( "Dextérité : {0}", "30" ));
  this.AddLabel( 20, 165, 255, string.Format( "Intelligence : {0}", "30" ));

  this.AddButton( 20, 195, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 195, 255, string.Format( "Retour en arrière" ));
  this.AddButton( 190, 195, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 210, 195, 255, string.Format( "Je serai un(e) humain(e)" ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 2:
   {
    m.Race = (Race) 1; // HUMAIN
    m.Str = 30;
    m.Dex = 30;
    m.Int = 30;
    m.Hits = m.HitsMax;
    m.Stam = m.StamMax;
    m.Mana = m.ManaMax;
    m.SendMessage( 0x26, "Vous êtes maintenant un(e) humain(e)" );
    m.SendGump( new ClasseGump() );
    break;
   }
  }
 }
}

public class ElfeGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public ElfeGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Elfe" );
  this.AddLabel( 20, 45, 255, string.Format( "La race elfique est proche de la nature et ils sont aussi" ));
  this.AddLabel( 20, 60, 255, string.Format( "sauvage et sans pitié qu'elle. Il la protège farouchement et" ));
  this.AddLabel( 20, 75, 255, string.Format( "s'entendent très mal avec les nains." ));

  this.AddLabel( 20, 105, 1149, string.Format( "Attributs de départ" ));
  this.AddLabel( 20, 135, 255, string.Format( "Force : {0}", "20" ));
  this.AddLabel( 20, 150, 255, string.Format( "Dextérité : {0}", "20" ));
  this.AddLabel( 20, 165, 255, string.Format( "Intelligence : {0}", "50" ));

  this.AddButton( 20, 195, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 195, 255, string.Format( "Retour en arrière" ));
  this.AddButton( 190, 195, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 210, 195, 255, string.Format( "Je serai un(e) elfe" ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 2:
   {
    m.Race = (Race) 2; // ELFE
    m.Hue = 576;
    m.Str = 20;
    m.Dex = 20;
    m.Int = 50;
    m.Hits = m.HitsMax;
    m.Stam = m.StamMax;
    m.Mana = m.ManaMax;
    m.SendGump( new ClasseGump() );
    m.SendMessage( 0x26, "Vous êtes maintenant un(e) elfe" );
    break;
   }
  }
 }
}

public class NainGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public NainGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Nain" );
  this.AddLabel( 20, 45, 255, string.Format( "La race naine est cupide mais travaillante et courageuse." ));
  this.AddLabel( 20, 60, 255, string.Format( "Les nains sont des personnes orgeuilleuses et fières. Ils" ));
  this.AddLabel( 20, 75, 255, string.Format( "s'entendent très mal avec les elfes." ));

  this.AddLabel( 20, 105, 1149, string.Format( "Attributs de départ" ));
  this.AddLabel( 20, 135, 255, string.Format( "Force : {0}", "50" ));
  this.AddLabel( 20, 150, 255, string.Format( "Dextérité : {0}", "20" ));
  this.AddLabel( 20, 165, 255, string.Format( "Intelligence : {0}", "20" ));

  this.AddButton( 20, 195, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 195, 255, string.Format( "Retour en arrière" ));
  this.AddButton( 190, 195, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 210, 195, 255, string.Format( "Je serai un(e) nain(e)" ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new CharCreationGump() );
    break;
   }
   case 2:
   {
    m.Race = (Race) 3; // NAIN
    m.Hue = 1719;
    m.Str = 50;
    m.Dex = 20;
    m.Int = 20;
    m.Hits = m.HitsMax;
    m.Stam = m.StamMax;
    m.Mana = m.ManaMax;
    m.SendGump( new ClasseGump() );
    m.SendMessage( 0x26, "Vous êtes maintenant un(e) nain(e)" );
    break;
   }
  }
 }
}

public class ClasseGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public ClasseGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Classes" );
  this.AddLabel( 20, 45, 255, string.Format( "Il vous faut choisir une classe pour votre personnage." ));

  this.AddButton( 20, 67, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 65, 255, string.Format( "Guerrier" ));
  this.AddButton( 20, 87, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 85, 255, string.Format( "Artisan" ));
  this.AddButton( 20, 107, 0x2623, 0x2622, 3, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 105, 255, string.Format( "Mage" ));

  this.AddLabel( 20, 145, 1149, string.Format( "Notez bien que chaque classe possède ses propres avantages" ));
  this.AddLabel( 20, 160, 1149, string.Format( "et inconvénients. Ceux-ci sont énumérés dans les pages" ));
  this.AddLabel( 20, 175, 1149, string.Format( "suivantes avec une courte description." ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new GuerrierGump() );
    break;
   }
   case 2:
   {
    m.SendGump( new ArtisanGump() );
    break;
   }
   case 3:
   {
    m.SendGump( new MageGump() );
    break;
   }
  }
 }
}

public class GuerrierGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public GuerrierGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Guerrier" );
  this.AddLabel( 20, 45, 255, string.Format( "Les guerriers maîtrisent les armes et portent de lourdes" ));
  this.AddLabel( 20, 60, 255, string.Format( "armures. On les voit souvent à dos de cheval et sont" ));
  this.AddLabel( 20, 75, 255, string.Format( "craints pour leurs habiletés au combat." ));

  this.AddLabel( 20, 105, 1149, string.Format( "Compétences à 30.0% :" ));
  this.AddLabel( 20, 135, 255, string.Format( "Archery, Fencing, Mace fighting, Parrying, Swordsmanship," ));
  this.AddLabel( 20, 150, 255, string.Format( "Tactics, Wrestling" ));

  this.AddButton( 20, 180, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 180, 255, string.Format( "Retour en arrière" ));
  this.AddButton( 190, 180, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 210, 180, 255, string.Format( "Je serai un(e) guerrier(e)" ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 2:
   {
    m.Classe = (Classe) 1; // GUERRIER
    m.Title = "Guerrier";
    for (int i = 0; i < m.Skills.Length; i++)
    {
     if ( m.Skills[i].Name != "Archery" && m.Skills[i].Name != "Fencing" && m.Skills[i].Name != "Macing" && m.Skills[i].Name != "Parry" && m.Skills[i].Name != "Swords" && m.Skills[i].Name != "Tactics" && m.Skills[i].Name != "Wrestling" )
     {
      m.Skills[i].Base = 0.0;
      m.Skills[i].Cap = 100.0;
     }
    }
    m.Skills[SkillName.Archery].Base = 30.0;
    m.Skills[SkillName.Archery].Cap = 150.0;
    m.Skills[SkillName.Fencing].Base = 30.0;
    m.Skills[SkillName.Fencing].Cap = 150.0;
    m.Skills[SkillName.Macing].Base = 30.0;
    m.Skills[SkillName.Macing].Cap = 150.0;
    m.Skills[SkillName.Parry].Base = 30.0;
    m.Skills[SkillName.Parry].Cap = 150.0;
    m.Skills[SkillName.Swords].Base = 30.0;
    m.Skills[SkillName.Swords].Cap = 150.0;
    m.Skills[SkillName.Tactics].Base = 30.0;
    m.Skills[SkillName.Tactics].Cap = 150.0;
    m.Skills[SkillName.Wrestling].Base = 30.0;
    m.Skills[SkillName.Wrestling].Cap = 150.0;

    if ( m.Female )
     m.EquipItem( new FemaleLeatherChest() );
    else
     m.EquipItem( new LeatherChest() );
    m.EquipItem( new LeatherArms() );
    m.EquipItem( new LeatherGloves() );
    m.EquipItem( new LeatherGorget() );
    m.EquipItem( new WoodenShield() );
    m.EquipItem( new LeatherLegs() );
    m.EquipItem( new Kryss() );
    m.EquipItem( new WoodenShield() );
    m.EquipItem( new Shoes( Utility.RandomYellowHue() ) );
    m.SendMessage( 0x26, "Vous êtes maintenant un(e) guerrier(e)" );
    break;
   }
  }
 }
}

public class ArtisanGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public ArtisanGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Artisan" );
  this.AddLabel( 20, 45, 255, string.Format( "Les artisans peuvent fabriquer différentes choses telles des" ));
  this.AddLabel( 20, 60, 255, string.Format( "armes ou des armures, des meubles, des vêtements, etc." ));
  this.AddLabel( 20, 75, 255, string.Format( "Ils sont généralement les personnages les plus riches." ));

  this.AddLabel( 20, 105, 1149, string.Format( "Compétences à 30.0% :" ));
  this.AddLabel( 20, 135, 255, string.Format( "Blacksmith, Bowcraft/Fletching, Carpentry, Tailoring," ));
  this.AddLabel( 20, 150, 255, string.Format( "Tinkering, Item Identification, Armslore" ));

  this.AddButton( 20, 180, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 180, 255, string.Format( "Retour en arrière" ));
  this.AddButton( 190, 180, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 210, 180, 255, string.Format( "Je serai un(e) artisan(e)" ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 2:
   {
    m.Classe = (Classe) 2; // ARTISAN
    m.Title = "Artisan";
    for (int i = 0; i < m.Skills.Length; i++)
    {
     if ( m.Skills[i].Name != "Blacksmith" && m.Skills[i].Name != "Fletching" && m.Skills[i].Name != "Carpentry" && m.Skills[i].Name != "Tailoring" && m.Skills[i].Name != "Tinkering" && m.Skills[i].Name != "ItemID" && m.Skills[i].Name != "Armslore" && m.Skills[i].Name != "Mining" && m.Skills[i].Name != "Lumberjacking" && m.Skills[i].Name != "Fishing" && m.Skills[i].Name != "Cooking" )
     {
      m.Skills[i].Base = 0.0;
      m.Skills[i].Cap = 100.0;
     }
    }
    m.Skills[SkillName.Mining].Base = 0.0;
    m.Skills[SkillName.Mining].Cap = 150.0;
    m.Skills[SkillName.Lumberjacking].Base = 0.0;
    m.Skills[SkillName.Lumberjacking].Cap = 150.0;
    m.Skills[SkillName.Fishing].Base = 0.0;
    m.Skills[SkillName.Fishing].Cap = 150.0;
    m.Skills[SkillName.Cooking].Base = 0.0;
    m.Skills[SkillName.Cooking].Cap = 150.0;

    m.Skills[SkillName.Blacksmith].Base = 30.0;
    m.Skills[SkillName.Blacksmith].Cap = 150.0;
    m.Skills[SkillName.Fletching].Base = 30.0;
    m.Skills[SkillName.Fletching].Cap = 150.0;
    m.Skills[SkillName.Carpentry].Base = 30.0;
    m.Skills[SkillName.Carpentry].Cap = 150.0;
    m.Skills[SkillName.Tailoring].Base = 30.0;
    m.Skills[SkillName.Tailoring].Cap = 150.0;
    m.Skills[SkillName.Tinkering].Base = 30.0;
    m.Skills[SkillName.Tinkering].Cap = 150.0;
    m.Skills[SkillName.ItemID].Base = 30.0;
    m.Skills[SkillName.ItemID].Cap = 150.0;
    m.Skills[SkillName.ArmsLore].Base = 30.0;
    m.Skills[SkillName.ArmsLore].Cap = 150.0;

    m.AddToBackpack( new TinkerTools() );
    m.AddToBackpack( new DovetailSaw() );
    m.AddToBackpack( new Scissors() );
    m.AddToBackpack( new SmithHammer() );
    m.AddToBackpack( new Pickaxe() );
    m.AddToBackpack( new FletcherTools() );
    m.AddToBackpack( new SewingKit() );
    m.AddToBackpack( new Hatchet() );

    switch ( Utility.Random( 3 ) )
    {
     case 0: m.EquipItem( new Shirt( Utility.RandomYellowHue() ) ); break;
     case 1: m.EquipItem( new FancyShirt( Utility.RandomYellowHue() ) ); break;
     case 2: m.EquipItem( new Doublet( Utility.RandomYellowHue() ) ); break;
    }
    if ( m.Female )
    {
     switch ( Utility.Random( 2 ) )
     {
      case 0: m.EquipItem( new Skirt( Utility.RandomYellowHue() ) ); break;
      case 1: m.EquipItem( new Kilt( Utility.RandomYellowHue() ) ); break;
     }
    }
    else
    {
     switch ( Utility.Random( 2 ) )
     {
      case 0: m.EquipItem( new LongPants( Utility.RandomYellowHue() ) ); break;
      case 1: m.EquipItem( new ShortPants( Utility.RandomYellowHue() ) ); break;
     }
    }

    m.EquipItem( new Shoes( Utility.RandomYellowHue() ) );
    m.EquipItem( new HalfApron( Utility.RandomYellowHue() ) );
    m.SendMessage( 0x26, "Vous êtes maintenant un(e) artisan(e)" );
    break;
   }
  }
 }
}

public class MageGump : Gump
{
 public void AddBlueBack( int width, int height )
 {
  this.AddBackground( 0, 0, width, height, 9270 );
  this.Closable=true;
  this.Disposable=true;
  this.Dragable=true;
  this.Resizable=false;
 }

 public MageGump() : base ( 0, 0 )
 {
  this.AddBlueBack( 400, 250 );

  this.AddLabel( 20, 15, 1149, "Mage" );
  this.AddLabel( 20, 45, 255, string.Format( "Les mages lancent des sorts, écrivent des parchemins" ));
  this.AddLabel( 20, 60, 255, string.Format( "magiques et enchantent les objets. Ils sont généralement" ));
  this.AddLabel( 20, 75, 255, string.Format( "peu bavards mais forment des ennemis redoutables." ));

  this.AddLabel( 20, 105, 1149, string.Format( "Compétences à 30.0% :" ));
  this.AddLabel( 20, 135, 255, string.Format( "Alchemy, Evaluating Intelligence, Inscription, Magery," ));
  this.AddLabel( 20, 150, 255, string.Format( "Meditation, Magic Resistance, Spirit Speak" ));

  this.AddButton( 20, 180, 0x2623, 0x2622, 1, GumpButtonType.Reply, 0 );
  this.AddLabel( 40, 180, 255, string.Format( "Retour en arrière" ));
  this.AddButton( 190, 180, 0x2623, 0x2622, 2, GumpButtonType.Reply, 0 );
  this.AddLabel( 210, 180, 255, string.Format( "Je serai un(e) mage" ));
 }

 public override void OnResponse( NetState state, RelayInfo info )
 {
  Mobile from = state.Mobile;
  PlayerMobile m = ( PlayerMobile ) from;
  int val = info.ButtonID;

  switch(val)
  {
   case 0:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 1:
   {
    m.SendGump( new ClasseGump() );
    break;
   }
   case 2:
   {
    m.Classe = (Classe) 3; // MAGE
    m.Title = "Mage";
    for (int i = 0; i < m.Skills.Length; i++)
    {
     if ( m.Skills[i].Name != "Alchemy" && m.Skills[i].Name != "Inscribe" && m.Skills[i].Name != "Magery" && m.Skills[i].Name != "Meditation" && m.Skills[i].Name != "MagicResist" && m.Skills[i].Name != "SpiritSpeak" && m.Skills[i].Name != "EvalInt" && m.Skills[i].Name != "Necromancy" )
     {
      m.Skills[i].Base = 0.0;
      m.Skills[i].Cap = 100.0;
     }
    }
    m.Skills[SkillName.Necromancy].Base = 0.0;
    m.Skills[SkillName.Necromancy].Cap = 150.0;

    m.Skills[SkillName.Alchemy].Base = 30.0;
    m.Skills[SkillName.Alchemy].Cap = 150.0;
    m.Skills[SkillName.Inscribe].Base = 30.0;
    m.Skills[SkillName.Inscribe].Cap = 150.0;
    m.Skills[SkillName.Magery].Base = 30.0;
    m.Skills[SkillName.Magery].Cap = 150.0;
    m.Skills[SkillName.Meditation].Base = 30.0;
    m.Skills[SkillName.Meditation].Cap = 150.0;
    m.Skills[SkillName.MagicResist].Base = 30.0;
    m.Skills[SkillName.MagicResist].Cap = 150.0;
    m.Skills[SkillName.SpiritSpeak].Base = 30.0;
    m.Skills[SkillName.SpiritSpeak].Cap = 150.0;
    m.Skills[SkillName.EvalInt].Base = 30.0;
    m.Skills[SkillName.EvalInt].Cap = 150.0;

    m.AddToBackpack( new Bottle() );
    m.AddToBackpack( new MortarPestle() );
    m.EquipItem( new Robe( Utility.RandomBlueHue() ) );
    m.EquipItem( new WizardsHat() );
    m.EquipItem( new Shoes( Utility.RandomYellowHue() ) );
    m.EquipItem( new GnarledStaff() );
    m.AddToBackpack( new Spellbook() );
    m.AddToBackpack( new BagOfReagents( 30 ) );

    for (int j = 0; j < 3; j++) // Je veux 3 scrolls
    {
     switch ( Utility.Random( 22 ) )
     {
      case  0: m.AddToBackpack( new ClumsyScroll() ); break;
      case  1: m.AddToBackpack( new CreateFoodScroll() ); break;
      case  2: m.AddToBackpack( new FeeblemindScroll() ); break;
      case  3: m.AddToBackpack( new HealScroll() ); break;
      case  4: m.AddToBackpack( new MagicArrowScroll() ); break;
      case  5: m.AddToBackpack( new NightSightScroll() ); break;
      case  6: m.AddToBackpack( new ReactiveArmorScroll() ); break;
      case  7: m.AddToBackpack( new WeakenScroll() ); break;
      case  8: m.AddToBackpack( new AgilityScroll() ); break;
      case  9: m.AddToBackpack( new CunningScroll() ); break;
      case 10: m.AddToBackpack( new CureScroll() ); break;
      case 11: m.AddToBackpack( new HarmScroll() ); break;
      case 12: m.AddToBackpack( new MagicTrapScroll() ); break;
      case 13: m.AddToBackpack( new MagicUnTrapScroll() ); break;
      case 14: m.AddToBackpack( new ProtectionScroll() ); break;
      case 15: m.AddToBackpack( new StrengthScroll() ); break;
      case 16: m.AddToBackpack( new BlessScroll() ); break;
      case 17: m.AddToBackpack( new FireballScroll() ); break;
      case 18: m.AddToBackpack( new MagicLockScroll() ); break;
      case 19: m.AddToBackpack( new PoisonScroll() ); break;
      case 20: m.AddToBackpack( new TelekinisisScroll() ); break;
      case 21: m.AddToBackpack( new UnlockScroll() ); break;
     }
    }

    m.SendMessage( 0x26, "Vous êtes maintenant un(e) mage" );
    break;
   }
  }
 }
}
}


Scripts\Misc\WelcomeTimer.cs
CODE
using System;
using Server.Network;
using Server.Gumps;
using Scripts.CharCreationGump;

namespace Server.Misc
{
/// <summary>
/// This timer spouts some welcome messages to a user at a set interval. It is used on character creation and login.
/// </summary>
public class WelcomeTimer : Timer
{
 private Mobile m_Mobile;
 private int m_State, m_Count;

 private static string[] m_Messages = new string[]
 {
  "Welcome to this test shard.  You are able to customize your character's stats and skills at anytime to anything you wish.  To see the commands to do this just say 'help'.",
  "You will find a bank check worth 1,000,000 gold in your bank!",
  "A spellbook and a bag of reagents has been placed into your bank box.",
  "Various tools have been placed into your bank.",
  "Various raw materials like ingots, logs, feathers, hides, bottles, etc, have been placed into your bank.",
  "5 unmarked recall runes, 5 Felucca moonstones and 5 Trammel moonstones have been placed into your bank box.",
  "One of each level of treasure map has been placed in your bank box.",
  "You will find 9000 silver pieces deposited into your bank box.  Spend it as you see fit and enjoy yourself!",
  "You will find 9000 gold pieces deposited into your bank box.  Spend it as you see fit and enjoy yourself!",
  "A bag of PowerScrolls has been placed in your bank box."
 };

 public WelcomeTimer( Mobile m ) : this( m, m_Messages.Length )
 {
 }

 public WelcomeTimer( Mobile m, int count ) : base( TimeSpan.FromSeconds( 1.0 ), TimeSpan.FromSeconds( 1.0 ) )
 {
  m_Mobile = m;
  m_Count = count;
 }

 protected override void OnTick()
 {
//   if ( m_State < m_Count )
//    m_Mobile.SendMessage( 0x35, m_Messages[m_State++] );

//   if ( m_State == m_Count )
//       {
   m_Mobile.SendGump(new CharCreationGump() );
   Stop();
//   }
 }
}
}


Scripts\Misc\CharacterCreation.cs
CODE
using System;
using Server;
using Server.Items;
using Server.Mobiles;
using Server.Network;
using Server.Accounting;
using Server.Custom;
using Server.Scripts.Commands;
using Server.Gumps;
using Server.Targeting;
using Scripts.CharCreationGump;
using Server.Misc;

namespace Server.Misc
{
public class CharacterCreation
{
 public static void Initialize()
 {
  // Register our event handler
  EventSink.CharacterCreated += new CharacterCreatedEventHandler( EventSink_CharacterCreated );
 }

 private static void AddBackpack( Mobile m )
 {
  Container pack = m.Backpack;

  if ( pack == null )
  {
   pack = new Backpack();
   pack.Movable = false;

   m.AddItem( pack );
  }

  PackItem( new Gold( 1000 ) ); // Starting gold can be customized here
  PackItem( new Dagger() );
 }

 private static void AddHair( Mobile m, int itemID, int hue )
 {
  Item item;

  switch ( itemID & 0x3FFF )
  {
   case 0x2044: item = new Mohawk( hue ); break;
   case 0x2045: item = new PageboyHair( hue ); break;
   case 0x2046: item = new BunsHair( hue ); break;
   case 0x2047: item = new Afro( hue ); break;
   case 0x2048: item = new ReceedingHair( hue ); break;
   case 0x2049: item = new TwoPigTails( hue ); break;
   case 0x204A: item = new KrisnaHair( hue ); break;
   case 0x203B: item = new ShortHair( hue ); break;
   case 0x203C: item = new LongHair( hue ); break;
   case 0x203D: item = new PonyTail( hue ); break;
   default: return;
  }

  m.AddItem( item );
 }

 private static void AddBeard( Mobile m, int itemID, int hue )
 {
  if ( m.Female )
   return;

  Item item;

  switch ( itemID & 0x3FFF )
  {
   case 0x203E: item = new LongBeard( hue ); break;
   case 0x203F: item = new ShortBeard( hue ); break;
   case 0x2040: item = new Goatee( hue ); break;
   case 0x2041: item = new Mustache( hue ); break;
   case 0x204B: item = new MediumShortBeard( hue ); break;
   case 0x204C: item = new MediumLongBeard( hue ); break;
   case 0x204D: item = new Vandyke( hue ); break;
   default: return;
  }

  m.AddItem( item );
 }

 private static Mobile CreateMobile( Account a )
 {
  for ( int i = 0; i < 5; ++i )
   if ( a[i] == null )
    return (a[i] = new PlayerMobile());

  return null;
 }

 private static Mobile m_Mobile;

 private static void EventSink_CharacterCreated( CharacterCreatedEventArgs args )
 {
  Mobile newChar = CreateMobile( args.Account as Account );

  if ( newChar == null )
  {
   Console.WriteLine( "Login: {0}: Character creation failed, account full", args.State );
   return;
  }

  args.Mobile = newChar;
  m_Mobile = newChar;

  newChar.Player = true;
  newChar.AccessLevel = ((Account)args.Account).AccessLevel;
  newChar.Female = args.Female;
  newChar.Body = newChar.Female ? 0x191 : 0x190;
  newChar.Hue = Utility.ClipSkinHue( args.Hue & 0x3FFF ) | 0x8000;
  newChar.Hunger = 20;

  SetName( newChar, args.Name );

  AddBackpack( newChar );
  AddHair( newChar, args.HairID, Utility.ClipHairHue( args.HairHue & 0x3FFF ) );
  AddBeard( newChar, args.BeardID, Utility.ClipHairHue( args.BeardHue & 0x3FFF ) );

  //CityInfo city = args.City;
  CityInfo city = new CityInfo( "Britain", "Sweet Dreams Inn", 1496, 1628, 10 );
  newChar.MoveToWorld( city.Location, Map.Felucca );

  Console.WriteLine( "Login: {0}: New character being created (account={1})", args.State, ((Account)args.Account).Username );
  Console.WriteLine( " - Character: {0} (serial={1})", newChar.Name, newChar.Serial );
  Console.WriteLine( " - Started: {0} {1}", city.City, city.Location );

  new WelcomeTimer( newChar ).Start();
 }

 private static void SetName( Mobile m, string name )
 {
  name = name.Trim();

  if ( !NameVerification.Validate( name, 2, 16, true, true, true, 1, NameVerification.SpaceDashPeriodQuote ) )
   name = "Generic Player";

  m.Name = name + ",";
 }


 private static void EquipItem( Item item )
 {
  EquipItem( item, false );
 }

 private static void EquipItem( Item item, bool mustEquip )
 {
  Container pack = m_Mobile.Backpack;

  if ( !mustEquip && pack != null )
   pack.DropItem( item );
  else
   item.Delete();
 }

 private static void PackItem( Item item )
 {
  Container pack = m_Mobile.Backpack;

  if ( pack != null )
   pack.DropItem( item );
  else
   item.Delete();
 }
}
}

Vortal - September 27, 2004 06:28 AM (GMT)
Suite :P


Scripts\Mobiles\PlayerMobile.cs
CODE
using System;
using System.Collections;
using Server;
using Server.Misc;
using Server.Items;
using Server.Gumps;
using Server.Multis;
using Server.Engines.Help;
using Server.ContextMenus;
using Server.Network;
using Server.Spells;
using Server.Spells.Fifth;
using Server.Spells.Seventh;
using Server.Targeting;
using Server.Engines.Quests;

namespace Server.Mobiles
{
[Flags]
public enum PlayerFlag // First 16 bits are reserved for default-distro use, start custom flags at 0x00010000
{
 None   = 0x00000000,
 Glassblowing  = 0x00000001,
 Masonry   = 0x00000002,
 SandMining  = 0x00000004,
 StoneMining  = 0x00000008,
 ToggleMiningStone = 0x00000010,
 KarmaLocked  = 0x00000020,
 AutoRenewInsurance = 0x00000040,
 UseOwnFilter  = 0x00000080,
 PublicMyRunUO  = 0x00000100,
 PagingSquelched  = 0x00000200
}

public enum NpcGuild
{
 None,
 MagesGuild,
 WarriorsGuild,
 ThievesGuild,
 RangersGuild,
 HealersGuild,
 MinersGuild,
 MerchantsGuild,
 TinkersGuild,
 TailorsGuild,
 FishermensGuild,
 BardsGuild,
 BlacksmithsGuild
}

// ************************************************
public enum Classe
{
 None,
 Guerrier,
 Artisan,
 Mage
}

public enum Race
{
 None,
 Humain,
 Elfe,
 Nain
}
// ************************************************

public class PlayerMobile : Mobile
{
 private class CountAndTimeStamp
 {
  private int m_Count;
  private DateTime m_Stamp;

  public CountAndTimeStamp()
  {
  }

  public DateTime TimeStamp { get{ return m_Stamp; } }
  public int Count
  {
   get { return m_Count; }
   set { m_Count = value; m_Stamp = DateTime.Now; }
  }
 }

 private DesignContext m_DesignContext;

 private NpcGuild m_NpcGuild;
 private DateTime m_NpcGuildJoinTime;
 private TimeSpan m_NpcGuildGameTime;
 private PlayerFlag m_Flags;
 private int m_StepsTaken;
 private int m_Profession;
 
// ************************************************************
 private Classe m_Classe;
 [CommandProperty( AccessLevel.GameMaster )]
 public Classe Classe
 {
  get{ return m_Classe; }
  set{ m_Classe = value; }
 }
 private Race m_Race;
 [CommandProperty( AccessLevel.GameMaster )]
 public Race Race
 {
  get{ return m_Race; }
  set{ m_Race = value; }
 }
// ************************************************************

 [CommandProperty( AccessLevel.GameMaster )]
 public int Profession
 {
  get{ return m_Profession; }
  set{ m_Profession = value; }
 }

 public int StepsTaken
 {
  get{ return m_StepsTaken; }
  set{ m_StepsTaken = value; }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public NpcGuild NpcGuild
 {
  get{ return m_NpcGuild; }
  set{ m_NpcGuild = value; }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public DateTime NpcGuildJoinTime
 {
  get{ return m_NpcGuildJoinTime; }
  set{ m_NpcGuildJoinTime = value; }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public TimeSpan NpcGuildGameTime
 {
  get{ return m_NpcGuildGameTime; }
  set{ m_NpcGuildGameTime = value; }
 }

 public PlayerFlag Flags
 {
  get{ return m_Flags; }
  set{ m_Flags = value; }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool PagingSquelched
 {
  get{ return GetFlag( PlayerFlag.PagingSquelched ); }
  set{ SetFlag( PlayerFlag.PagingSquelched, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool Glassblowing
 {
  get{ return GetFlag( PlayerFlag.Glassblowing ); }
  set{ SetFlag( PlayerFlag.Glassblowing, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool Masonry
 {
  get{ return GetFlag( PlayerFlag.Masonry ); }
  set{ SetFlag( PlayerFlag.Masonry, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool SandMining
 {
  get{ return GetFlag( PlayerFlag.SandMining ); }
  set{ SetFlag( PlayerFlag.SandMining, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool StoneMining
 {
  get{ return GetFlag( PlayerFlag.StoneMining ); }
  set{ SetFlag( PlayerFlag.StoneMining, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool ToggleMiningStone
 {
  get{ return GetFlag( PlayerFlag.ToggleMiningStone ); }
  set{ SetFlag( PlayerFlag.ToggleMiningStone, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool KarmaLocked
 {
  get{ return GetFlag( PlayerFlag.KarmaLocked ); }
  set{ SetFlag( PlayerFlag.KarmaLocked, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool AutoRenewInsurance
 {
  get{ return GetFlag( PlayerFlag.AutoRenewInsurance ); }
  set{ SetFlag( PlayerFlag.AutoRenewInsurance, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool UseOwnFilter
 {
  get{ return GetFlag( PlayerFlag.UseOwnFilter ); }
  set{ SetFlag( PlayerFlag.UseOwnFilter, value ); }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public bool PublicMyRunUO
 {
  get{ return GetFlag( PlayerFlag.PublicMyRunUO ); }
  set{ SetFlag( PlayerFlag.PublicMyRunUO, value ); InvalidateMyRunUO(); }
 }

 public static Direction GetDirection4( Point3D from, Point3D to )
 {
  int dx = from.X - to.X;
  int dy = from.Y - to.Y;

  int rx = dx - dy;
  int ry = dx + dy;

  Direction ret;

  if ( rx >= 0 && ry >= 0 )
   ret = Direction.West;
  else if ( rx >= 0 && ry < 0 )
   ret = Direction.South;
  else if ( rx < 0 && ry < 0 )
   ret = Direction.East;
  else
   ret = Direction.North;

  return ret;
 }

 public override bool OnDroppedItemToWorld( Item item, Point3D location )
 {
  if ( !base.OnDroppedItemToWorld( item, location ) )
   return false;

  BounceInfo bi = item.GetBounce();

  if ( bi != null )
  {
   Type type = item.GetType();

   if ( type.IsDefined( typeof( FurnitureAttribute ), true ) || type.IsDefined( typeof( DynamicFlipingAttribute ), true ) )
   {
    object[] objs = type.GetCustomAttributes( typeof( FlipableAttribute ), true );

    if ( objs != null && objs.Length > 0 )
    {
     FlipableAttribute fp = objs[0] as FlipableAttribute;

     if ( fp != null )
     {
      int[] itemIDs = fp.ItemIDs;

      Point3D oldWorldLoc = bi.m_WorldLoc;
      Point3D newWorldLoc = location;

      if ( oldWorldLoc.X != newWorldLoc.X || oldWorldLoc.Y != newWorldLoc.Y )
      {
       Direction dir = GetDirection4( oldWorldLoc, newWorldLoc );

       if ( itemIDs.Length == 2 )
       {
        switch ( dir )
        {
         case Direction.North:
         case Direction.South: item.ItemID = itemIDs[0]; break;
         case Direction.East:
         case Direction.West: item.ItemID = itemIDs[1]; break;
        }
       }
       else if ( itemIDs.Length == 4 )
       {
        switch ( dir )
        {
         case Direction.South: item.ItemID = itemIDs[0]; break;
         case Direction.East: item.ItemID = itemIDs[1]; break;
         case Direction.North: item.ItemID = itemIDs[2]; break;
         case Direction.West: item.ItemID = itemIDs[3]; break;
        }
       }
      }
     }
    }
   }
  }

  return true;
 }

 public bool GetFlag( PlayerFlag flag )
 {
  return ( (m_Flags & flag) != 0 );
 }

 public void SetFlag( PlayerFlag flag, bool value )
 {
  if ( value )
   m_Flags |= flag;
  else
   m_Flags &= ~flag;
 }

 public DesignContext DesignContext
 {
  get{ return m_DesignContext; }
  set{ m_DesignContext = value; }
 }

 public static void Initialize()
 {
  if ( FastwalkPrevention )
  {
   PacketHandler ph = PacketHandlers.GetHandler( 0x02 );

   ph.ThrottleCallback = new ThrottlePacketCallback( MovementThrottle_Callback );
  }

  EventSink.Login += new LoginEventHandler( OnLogin );
  EventSink.Logout += new LogoutEventHandler( OnLogout );
  EventSink.Connected += new ConnectedEventHandler( EventSink_Connected );
  EventSink.Disconnected += new DisconnectedEventHandler( EventSink_Disconnected );
 }

 public override void OnSkillInvalidated( Skill skill )
 {
  if ( Core.AOS && skill.SkillName == SkillName.MagicResist )
   UpdateResistances();
 }

 public override int GetMaxResistance( ResistanceType type )
 {
  int max = base.GetMaxResistance( type );

  if ( type != ResistanceType.Physical && 60 < max && Spells.Fourth.CurseSpell.UnderEffect( this ) )
   max = 60;

  return max;
 }

 private int m_LastGlobalLight = -1, m_LastPersonalLight = -1;

 public override void OnNetStateChanged()
 {
  m_LastGlobalLight = -1;
  m_LastPersonalLight = -1;
 }

 public override void ComputeBaseLightLevels( out int global, out int personal )
 {
  global = LightCycle.ComputeLevelFor( this );
  personal = this.LightLevel;
 }

 public override void CheckLightLevels( bool forceResend )
 {
  NetState ns = this.NetState;

  if ( ns == null )
   return;

  int global, personal;

  ComputeLightLevels( out global, out personal );

  if ( !forceResend )
   forceResend = ( global != m_LastGlobalLight || personal != m_LastPersonalLight );

  if ( !forceResend )
   return;

  m_LastGlobalLight = global;
  m_LastPersonalLight = personal;

  ns.Send( GlobalLightLevel.Instantiate( global ) );
  ns.Send( new PersonalLightLevel( this, personal ) );
 }

 public override int GetMinResistance( ResistanceType type )
 {
  int magicResist = (int)(Skills[SkillName.MagicResist].Value * 10);
  int min = int.MinValue;

  if ( magicResist >= 1000 )
   min = 40 + ((magicResist - 1000) / 50);
  else if ( magicResist >= 400 )
   min = (magicResist - 400) / 15;

  if ( min > MaxPlayerResistance )
   min = MaxPlayerResistance;

  int baseMin = base.GetMinResistance( type );

  if ( min < baseMin )
   min = baseMin;

  return min;
 }

 private static void OnLogin( LoginEventArgs e )
 {
  Mobile from = e.Mobile;

  SacrificeVirtue.CheckAtrophy( from );
  JusticeVirtue.CheckAtrophy( from );
  CompassionVirtue.CheckAtrophy( from );

  if ( AccountHandler.LockdownLevel > AccessLevel.Player )
  {
   string notice;

   Accounting.Account acct = from.Account as Accounting.Account;

   if ( acct == null || !acct.HasAccess( from.NetState ) )
   {
    if ( from.AccessLevel == AccessLevel.Player )
     notice = "The server is currently under lockdown. No players are allowed to log in at this time.";
    else
     notice = "The server is currently under lockdown. You do not have sufficient access level to connect.";

    Timer.DelayCall( TimeSpan.FromSeconds( 1.0 ), new TimerStateCallback( Disconnect ), from );
   }
   else if ( from.AccessLevel == AccessLevel.Administrator )
   {
    notice = "The server is currently under lockdown. As you are an administrator, you may change this from the [Admin gump.";
   }
   else
   {
    notice = "The server is currently under lockdown. You have sufficient access level to connect.";
   }

   from.SendGump( new NoticeGump( 1060637, 30720, notice, 0xFFC000, 300, 140, null, null ) );
  }
 }

 private bool m_NoDeltaRecursion;

 public void ValidateEquipment()
 {
  if ( m_NoDeltaRecursion || Map == null || Map == Map.Internal )
   return;

  if ( this.Items == null )
   return;

  m_NoDeltaRecursion = true;
  Timer.DelayCall( TimeSpan.Zero, new TimerCallback( ValidateEquipment_Sandbox ) );
 }

 private void ValidateEquipment_Sandbox()
 {
  try
  {
   if ( Map == null || Map == Map.Internal )
    return;

   ArrayList items = this.Items;

   if ( items == null )
    return;

   bool moved = false;

   int str = this.Str;
   int dex = this.Dex;
   int intel = this.Int;

   Mobile from = this;

   for ( int i = items.Count - 1; i >= 0; --i )
   {
    if ( i >= items.Count )
     continue;

    Item item = (Item)items[i];

    if ( item is BaseWeapon )
    {
     BaseWeapon weapon = (BaseWeapon)item;

     bool drop = false;

     if ( dex < weapon.DexRequirement )
      drop = true;
     else if ( str < AOS.Scale( weapon.StrRequirement, 100 - weapon.GetLowerStatReq() ) )
      drop = true;
     else if ( intel < weapon.IntRequirement )
      drop = true;

     if ( drop )
     {
      string name = weapon.Name;

      if ( name == null )
       name = String.Format( "#{0}", weapon.LabelNumber );

      from.SendLocalizedMessage( 1062001, name ); // You can no longer wield your ~1_WEAPON~
      from.AddToBackpack( weapon );
      moved = true;
     }
    }
    else if ( item is BaseArmor )
    {
     BaseArmor armor = (BaseArmor)item;

     bool drop = false;

     if ( !armor.AllowMaleWearer && from.Body.IsMale && from.AccessLevel < AccessLevel.GameMaster )
     {
      drop = true;
     }
     else if ( !armor.AllowFemaleWearer && from.Body.IsFemale && from.AccessLevel < AccessLevel.GameMaster )
     {
      drop = true;
     }
     else
     {
      int strBonus = armor.ComputeStatBonus( StatType.Str ), strReq = armor.ComputeStatReq( StatType.Str );
      int dexBonus = armor.ComputeStatBonus( StatType.Dex ), dexReq = armor.ComputeStatReq( StatType.Dex );
      int intBonus = armor.ComputeStatBonus( StatType.Int ), intReq = armor.ComputeStatReq( StatType.Int );

      if ( dex < dexReq || (dex + dexBonus) < 1 )
       drop = true;
      else if ( str < strReq || (str + strBonus) < 1 )
       drop = true;
      else if ( intel < intReq || (intel + intBonus) < 1 )
       drop = true;
     }

     if ( drop )
     {
      string name = armor.Name;

      if ( name == null )
       name = String.Format( "#{0}", armor.LabelNumber );

      if ( armor is BaseShield )
       from.SendLocalizedMessage( 1062003, name ); // You can no longer equip your ~1_SHIELD~
      else
       from.SendLocalizedMessage( 1062002, name ); // You can no longer wear your ~1_ARMOR~

      from.AddToBackpack( armor );
      moved = true;
     }
    }
   }

   if ( moved )
    from.SendLocalizedMessage( 500647 ); // Some equipment has been moved to your backpack.
  }
  catch ( Exception e )
  {
   Console.WriteLine( e );
  }
  finally
  {
   m_NoDeltaRecursion = false;
  }
 }

 public override void Delta( MobileDelta flag )
 {
  base.Delta( flag );

  if ( (flag & MobileDelta.Stat) != 0 )
   ValidateEquipment();

  if ( (flag & (MobileDelta.Name | MobileDelta.Hue)) != 0 )
   InvalidateMyRunUO();
 }

 private static void Disconnect( object state )
 {
  NetState ns = ((Mobile)state).NetState;

  if ( ns != null )
   ns.Dispose();
 }

 private static void OnLogout( LogoutEventArgs e )
 {
 }

 private static void EventSink_Connected( ConnectedEventArgs e )
 {
  PlayerMobile pm = e.Mobile as PlayerMobile;

  if ( pm != null )
  {
   pm.m_SessionStart = DateTime.Now;

   if ( pm.m_Quest != null )
    pm.m_Quest.StartTimer();
  }
 }

 private static void EventSink_Disconnected( DisconnectedEventArgs e )
 {
  Mobile from = e.Mobile;
  DesignContext context = DesignContext.Find( from );

  if ( context != null )
  {
   /* Client disconnected
    *  - Remove design context
    *  - Eject client from house
    */

   // Remove design context
   DesignContext.Remove( from );

   // Eject client from house
   from.RevealingAction();

   from.MoveToWorld( context.Foundation.BanLocation, context.Foundation.Map );
  }

  PlayerMobile pm = e.Mobile as PlayerMobile;

  if ( pm != null )
  {
   pm.m_GameTime += (DateTime.Now - pm.m_SessionStart);

   if ( pm.m_Quest != null )
    pm.m_Quest.StopTimer();
  }
 }

 public override void RevealingAction()
 {
  if ( m_DesignContext != null )
   return;

  Spells.Sixth.InvisibilitySpell.RemoveTimer( this );

  base.RevealingAction();
 }

 public override void OnSubItemAdded( Item item )
 {
  if ( AccessLevel < AccessLevel.GameMaster && item.IsChildOf( this.Backpack ) )
  {
   int maxWeight = WeightOverloading.GetMaxWeight( this );
   int curWeight = Mobile.BodyWeight + this.TotalWeight;

   if ( curWeight > maxWeight )
    this.SendLocalizedMessage( 1019035, true, String.Format( " : {0} / {1}", curWeight, maxWeight ) );
  }
 }

 public override bool CanBeHarmful( Mobile target, bool message, bool ignoreOurBlessedness )
 {
  if ( m_DesignContext != null || (target is PlayerMobile && ((PlayerMobile)target).m_DesignContext != null) )
   return false;

  if ( (target is BaseVendor && ((BaseVendor)target).IsInvulnerable) || target is PlayerVendor || target is TownCrier )
  {
   if ( message )
   {
    if ( target.Title == null )
     SendMessage( "{0} the vendor cannot be harmed.", target.Name );
    else
     SendMessage( "{0} {1} cannot be harmed.", target.Name, target.Title );
   }

   return false;
  }

  return base.CanBeHarmful( target, message, ignoreOurBlessedness );
 }

 public override bool CanBeBeneficial( Mobile target, bool message, bool allowDead )
 {
  if ( m_DesignContext != null || (target is PlayerMobile && ((PlayerMobile)target).m_DesignContext != null) )
   return false;

  return base.CanBeBeneficial( target, message, allowDead );
 }

 public override bool CheckContextMenuDisplay( IEntity target )
 {
  return ( m_DesignContext == null );
 }

 public override void OnItemAdded( Item item )
 {
  base.OnItemAdded( item );

  if ( item is BaseArmor || item is BaseWeapon )
  {
   Hits=Hits; Stam=Stam; Mana=Mana;
  }

  InvalidateMyRunUO();
 }

 public override void OnItemRemoved( Item item )
 {
  base.OnItemRemoved( item );

  if ( item is BaseArmor || item is BaseWeapon )
  {
   Hits=Hits; Stam=Stam; Mana=Mana;
  }

  InvalidateMyRunUO();
 }

 public override int HitsMax
 {
  get
  {
   int strBase;
   int strOffs = GetStatOffset( StatType.Str );

   if ( Core.AOS )
   {
    strBase = this.Str;
    strOffs += AosAttributes.GetValue( this, AosAttribute.BonusHits );
   }
   else
   {
    strBase = this.RawStr;
   }

   return (strBase / 2) + 50 + strOffs;
  }
 }

 public override int StamMax
 {
  get{ return base.StamMax + AosAttributes.GetValue( this, AosAttribute.BonusStam ); }
 }

 public override int ManaMax
 {
  get{ return base.ManaMax + AosAttributes.GetValue( this, AosAttribute.BonusMana ); }
 }

 public override bool Move( Direction d )
 {
  NetState ns = this.NetState;

  if ( ns != null )
  {
   Gump[] gumps = ns.Gumps;

   for ( int i = 0; i < gumps.Length; ++i )
   {
    if ( gumps[i] is ResurrectGump )
    {
     if ( Alive )
     {
      CloseGump( typeof( ResurrectGump ) );
     }
     else
     {
      SendLocalizedMessage( 500111 ); // You are frozen and cannot move.
      return false;
     }
    }
   }
  }

  TimeSpan speed = ComputeMovementSpeed( d );

  if ( !base.Move( d ) )
   return false;

  m_NextMovementTime += speed;
  return true;
 }

 public override bool CheckMovement( Direction d, out int newZ )
 {
  DesignContext context = m_DesignContext;

  if ( context == null )
   return base.CheckMovement( d, out newZ );

  HouseFoundation foundation = context.Foundation;

  newZ = foundation.Z + HouseFoundation.GetLevelZ( context.Level );

  int newX = this.X, newY = this.Y;
  Movement.Movement.Offset( d, ref newX, ref newY );

  int startX = foundation.X + foundation.Components.Min.X + 1;
  int startY = foundation.Y + foundation.Components.Min.Y + 1;
  int endX = startX + foundation.Components.Width - 1;
  int endY = startY + foundation.Components.Height - 2;

  return ( newX >= startX && newY >= startY && newX < endX && newY < endY && Map == foundation.Map );
 }

 public override bool AllowItemUse( Item item )
 {
  return DesignContext.Check( this );
 }

 public override bool AllowSkillUse( SkillName skill )
 {
  return DesignContext.Check( this );
 }

 private bool m_LastProtectedMessage;
 private int m_NextProtectionCheck = 10;

 public virtual void RecheckTownProtection()
 {
  m_NextProtectionCheck = 10;

  Regions.GuardedRegion reg = this.Region as Regions.GuardedRegion;
  bool isProtected = ( reg != null && !reg.IsDisabled() );

  if ( isProtected != m_LastProtectedMessage )
  {
   if ( isProtected )
    SendLocalizedMessage( 500112 ); // You are now under the protection of the town guards.
   else
    SendLocalizedMessage( 500113 ); // You have left the protection of the town guards.

   m_LastProtectedMessage = isProtected;
  }
 }

 public override void MoveToWorld( Point3D loc, Map map )
 {
  base.MoveToWorld( loc, map );

  RecheckTownProtection();
 }

 public override void SetLocation( Point3D loc, bool isTeleport )
 {
  base.SetLocation( loc, isTeleport );

  if ( isTeleport || --m_NextProtectionCheck == 0 )
   RecheckTownProtection();
 }

 public override void GetContextMenuEntries( Mobile from, ArrayList list )
 {
  base.GetContextMenuEntries( from, list );

  if ( from == this )
  {
   if ( m_Quest != null )
    m_Quest.GetContextMenuEntries( list );

   if ( Alive && InsuranceEnabled )
   {
    list.Add( new CallbackEntry( 6201, new ContextCallback( ToggleItemInsurance ) ) );

    if ( AutoRenewInsurance )
     list.Add( new CallbackEntry( 6202, new ContextCallback( CancelRenewInventoryInsurance ) ) );
    else
     list.Add( new CallbackEntry( 6200, new ContextCallback( AutoRenewInventoryInsurance ) ) );
   }

   // TODO: Toggle champ titles

   BaseHouse house = BaseHouse.FindHouseAt( this );

   if ( house != null && house.IsAosRules )
    list.Add( new CallbackEntry( 6207, new ContextCallback( LeaveHouse ) ) );

   if ( m_JusticeProtectors.Count > 0 )
    list.Add( new CallbackEntry( 6157, new ContextCallback( CancelProtection ) ) );
  }
 }

 private void CancelProtection()
 {
  for ( int i = 0; i < m_JusticeProtectors.Count; ++i )
  {
   Mobile prot = (Mobile)m_JusticeProtectors[i];

   string args = String.Format( "{0}\t{1}", this.Name, prot.Name );

   prot.SendLocalizedMessage( 1049371, args ); // The protective relationship between ~1_PLAYER1~ and ~2_PLAYER2~ has been ended.
   this.SendLocalizedMessage( 1049371, args ); // The protective relationship between ~1_PLAYER1~ and ~2_PLAYER2~ has been ended.
  }

  m_JusticeProtectors.Clear();
 }

 private void ToggleItemInsurance()
 {
  if ( !CheckAlive() )
   return;

  BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
  SendLocalizedMessage( 1060868 ); // Target the item you wish to toggle insurance status on <ESC> to cancel
 }

 private bool CanInsure( Item item )
 {
  if ( item is Container )
   return false;

  if ( item is Spellbook || item is Runebook || item is PotionKeg )
   return false;

  if ( item.Stackable )
   return false;

  if ( item.LootType == LootType.Cursed )
   return false;

  if ( item.ItemID == 0x204E ) // death shroud
   return false;

  return true;
 }

 private void ToggleItemInsurance_Callback( Mobile from, object obj )
 {
  if ( !CheckAlive() )
   return;

  Item item = obj as Item;

  if ( item == null || !item.IsChildOf( this ) )
  {
   BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
   SendLocalizedMessage( 1060871, "", 0x23 ); // You can only insure items that you have equipped or that are in your backpack
  }
  else if ( item.Insured )
  {
   item.Insured = false;

   SendLocalizedMessage( 1060874, "", 0x35 ); // You cancel the insurance on the item

   BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
   SendLocalizedMessage( 1060868, "", 0x23 ); // Target the item you wish to toggle insurance status on <ESC> to cancel
  }
  else if ( !CanInsure( item ) )
  {
   BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
   SendLocalizedMessage( 1060869, "", 0x23 ); // You cannot insure that
  }
  else if ( item.LootType == LootType.Blessed || item.LootType == LootType.Newbied || item.BlessedFor == from )
  {
   BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
   SendLocalizedMessage( 1060870, "", 0x23 ); // That item is blessed and does not need to be insured
   SendLocalizedMessage( 1060869, "", 0x23 ); // You cannot insure that
  }
  else
  {
   if ( !item.PayedInsurance )
   {
    if ( Banker.Withdraw( from, 600 ) )
    {
     SendLocalizedMessage( 1060398, "600" ); // ~1_AMOUNT~ gold has been withdrawn from your bank box.
     item.PayedInsurance = true;
    }
    else
    {
     SendLocalizedMessage( 1061079, "", 0x23 ); // You lack the funds to purchase the insurance
     return;
    }
   }

   item.Insured = true;

   SendLocalizedMessage( 1060873, "", 0x23 ); // You have insured the item

   BeginTarget( -1, false, TargetFlags.None, new TargetCallback( ToggleItemInsurance_Callback ) );
   SendLocalizedMessage( 1060868, "", 0x23 ); // Target the item you wish to toggle insurance status on <ESC> to cancel
  }
 }

 private void AutoRenewInventoryInsurance()
 {
  if ( !CheckAlive() )
   return;

  SendLocalizedMessage( 1060881, "", 0x23 ); // You have selected to automatically reinsure all insured items upon death
  AutoRenewInsurance = true;
 }

 private void CancelRenewInventoryInsurance()
 {
  if ( !CheckAlive() )
   return;

  SendLocalizedMessage( 1061075, "", 0x23 ); // You have cancelled automatically reinsuring all insured items upon death
  AutoRenewInsurance = false;
 }

 // TODO: Champ titles, toggle

 private void LeaveHouse()
 {
  BaseHouse house = BaseHouse.FindHouseAt( this );

  if ( house != null )
   this.Location = house.BanLocation;
 }

 private delegate void ContextCallback();

 private class CallbackEntry : ContextMenuEntry
 {
  private ContextCallback m_Callback;

  public CallbackEntry( int number, ContextCallback callback ) : this( number, -1, callback )
  {
  }

  public CallbackEntry( int number, int range, ContextCallback callback ) : base( number, range )
  {
   m_Callback = callback;
  }

  public override void OnClick()
  {
   if ( m_Callback != null )
    m_Callback();
  }
 }

 public override void OnDoubleClick( Mobile from )
 {
  if ( this == from && !Warmode )
  {
   IMount mount = Mount;

   if ( mount != null && !DesignContext.Check( this ) )
    return;
  }

  base.OnDoubleClick( from );
 }

 public override void DisplayPaperdollTo( Mobile to )
 {
  if ( DesignContext.Check( this ) )
   base.DisplayPaperdollTo( to );
 }

 private static bool m_NoRecursion;

 protected override void OnLocationChange( Point3D oldLocation )
 {
  CheckLightLevels( false );

  DesignContext context = m_DesignContext;

  if ( context == null || m_NoRecursion )
   return;

  m_NoRecursion = true;

  HouseFoundation foundation = context.Foundation;

  int newX = this.X, newY = this.Y;
  int newZ = foundation.Z + HouseFoundation.GetLevelZ( context.Level );

  int startX = foundation.X + foundation.Components.Min.X + 1;
  int startY = foundation.Y + foundation.Components.Min.Y + 1;
  int endX = startX + foundation.Components.Width - 1;
  int endY = startY + foundation.Components.Height - 2;

  if ( newX >= startX && newY >= startY && newX < endX && newY < endY && Map == foundation.Map )
  {
   if ( Z != newZ )
    Location = new Point3D( X, Y, newZ );

   m_NoRecursion = false;
   return;
  }

  Location = new Point3D( foundation.X, foundation.Y, newZ );
  Map = foundation.Map;

  m_NoRecursion = false;
 }

 protected override void OnMapChange( Map oldMap )
 {
  DesignContext context = m_DesignContext;

  if ( context == null || m_NoRecursion )
   return;

  m_NoRecursion = true;

  HouseFoundation foundation = context.Foundation;

  if ( Map != foundation.Map )
   Map = foundation.Map;

  m_NoRecursion = false;
 }

 public override void OnDamage( int amount, Mobile from, bool willKill )
 {
  if ( amount > (Core.AOS ? 25 : 0) )
  {
   BandageContext c = BandageContext.GetContext( this );

   if ( c != null )
    c.Slip();
  }

  WeightOverloading.FatigueOnDamage( this, amount );

  base.OnDamage( amount, from, willKill );
 }

 public static int ComputeSkillTotal( Mobile m )
 {
  int total = 0;

  for ( int i = 0; i < m.Skills.Length; ++i )
   total += m.Skills[i].BaseFixedPoint;

  return ( total / 10 );
 }

 public override void Resurrect()
 {
  bool wasAlive = this.Alive;

  base.Resurrect();

  if ( this.Alive && !wasAlive )
  {
   Item deathRobe = new DeathRobe();

   if ( !EquipItem( deathRobe ) )
    deathRobe.Delete();
  }
 }

 private Mobile m_InsuranceAward;
 private int m_InsuranceCost;
 private int m_InsuranceBonus;

 public override bool OnBeforeDeath()
 {
  m_InsuranceCost = 0;
  m_InsuranceAward = base.FindMostRecentDamager( false );

  if ( m_InsuranceAward != null && !m_InsuranceAward.Player )
   m_InsuranceAward = null;

  if ( m_InsuranceAward is PlayerMobile )
   ((PlayerMobile)m_InsuranceAward).m_InsuranceBonus = 0;

  return base.OnBeforeDeath();
 }

 private bool CheckInsuranceOnDeath( Item item )
 {
  if ( InsuranceEnabled && item.Insured )
  {
   if ( AutoRenewInsurance )
   {
    int cost = ( m_InsuranceAward == null ? 600 : 300 );

    if ( Banker.Withdraw( this, cost ) )
    {
     m_InsuranceCost += cost;
     item.PayedInsurance = true;
    }
    else
    {
     SendLocalizedMessage( 1061079, "", 0x23 ); // You lack the funds to purchase the insurance
     item.PayedInsurance = false;
     item.Insured = false;
    }
   }
   else
   {
    item.PayedInsurance = false;
    item.Insured = false;
   }

   if ( m_InsuranceAward != null )
   {
    if ( Banker.Deposit( m_InsuranceAward, 300 ) )
    {
     if ( m_InsuranceAward is PlayerMobile )
      ((PlayerMobile)m_InsuranceAward).m_InsuranceBonus += 300;
    }
   }

   return true;
  }

  return false;
 }

 public override DeathMoveResult GetParentMoveResultFor( Item item )
 {
  if ( CheckInsuranceOnDeath( item ) )
   return DeathMoveResult.MoveToBackpack;

  return base.GetParentMoveResultFor( item );
 }

 public override DeathMoveResult GetInventoryMoveResultFor( Item item )
 {
  if ( CheckInsuranceOnDeath( item ) )
   return DeathMoveResult.MoveToBackpack;

  return base.GetInventoryMoveResultFor( item );
 }

 public override void OnDeath( Container c )
 {
  base.OnDeath( c );

  HueMod = -1;
  NameMod = null;
  SavagePaintExpiration = TimeSpan.Zero;

  SetHairMods( -1, -1 );

  PolymorphSpell.StopTimer( this );
  IncognitoSpell.StopTimer( this );
  DisguiseGump.StopTimer( this );

  EndAction( typeof( PolymorphSpell ) );
  EndAction( typeof( IncognitoSpell ) );

  MeerMage.StopEffect( this, false );

  if ( m_PermaFlags.Count > 0 )
  {
   m_PermaFlags.Clear();

   if ( c is Corpse )
    ((Corpse)c).Criminal = true;

   if ( SkillHandlers.Stealing.ClassicMode )
    Criminal = true;
  }

  if ( this.Kills >= 5 && DateTime.Now >= m_NextJustAward )
  {
   Mobile m = FindMostRecentDamager( false );

   if ( m != null && m.Player )
   {
    bool gainedPath = false;

    int theirTotal = ComputeSkillTotal( m );
    int ourTotal = ComputeSkillTotal( this );

    int pointsToGain = 1 + ((theirTotal - ourTotal) / 50);

    if ( pointsToGain < 1 )
     pointsToGain = 1;
    else if ( pointsToGain > 4 )
     pointsToGain = 4;

    if ( VirtueHelper.Award( m, VirtueName.Justice, pointsToGain, ref gainedPath ) )
    {
     if ( gainedPath )
      m.SendLocalizedMessage( 1049367 ); // You have gained a path in Justice!
     else
      m.SendLocalizedMessage( 1049363 ); // You have gained in Justice.

     m.FixedParticles( 0x375A, 9, 20, 5027, EffectLayer.Waist );
     m.PlaySound( 0x1F7 );

     m_NextJustAward = DateTime.Now + TimeSpan.FromMinutes( pointsToGain * 2 );
    }
   }
  }

  if ( m_InsuranceCost > 0 )
   SendLocalizedMessage( 1060398, m_InsuranceCost.ToString() ); // ~1_AMOUNT~ gold has been withdrawn from your bank box.

  if ( m_InsuranceAward is PlayerMobile )
  {
   PlayerMobile pm = (PlayerMobile)m_InsuranceAward;

   if ( pm.m_InsuranceBonus > 0 )
    pm.SendLocalizedMessage( 1060397, pm.m_InsuranceBonus.ToString() ); // ~1_AMOUNT~ gold has been deposited into your bank box.
  }
 }

 private ArrayList m_PermaFlags;
 private ArrayList m_VisList;
 private Hashtable m_AntiMacroTable;
 private TimeSpan m_GameTime;
 private TimeSpan m_ShortTermElapse;
 private TimeSpan m_LongTermElapse;
 private DateTime m_SessionStart;
 private DateTime m_LastEscortTime;
 private DateTime m_NextSmithBulkOrder;
 private DateTime m_NextTailorBulkOrder;
 private DateTime m_SavagePaintExpiration;
 private SkillName m_Learning = (SkillName)(-1);

 public SkillName Learning
 {
  get{ return m_Learning; }
  set{ m_Learning = value; }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public TimeSpan SavagePaintExpiration
 {
  get
  {
   TimeSpan ts = m_SavagePaintExpiration - DateTime.Now;

   if ( ts < TimeSpan.Zero )
    ts = TimeSpan.Zero;

   return ts;
  }
  set
  {
   m_SavagePaintExpiration = DateTime.Now + value;
  }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public TimeSpan NextSmithBulkOrder
 {
  get
  {
   TimeSpan ts = m_NextSmithBulkOrder - DateTime.Now;

   if ( ts < TimeSpan.Zero )
    ts = TimeSpan.Zero;

   return ts;
  }
  set
  {
   try{ m_NextSmithBulkOrder = DateTime.Now + value; }
   catch{}
  }
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public TimeSpan NextTailorBulkOrder
 {
  get
  {
   TimeSpan ts = m_NextTailorBulkOrder - DateTime.Now;

   if ( ts < TimeSpan.Zero )
    ts = TimeSpan.Zero;

   return ts;
  }
  set
  {
   try{ m_NextTailorBulkOrder = DateTime.Now + value; }
   catch{}
  }
 }

 public DateTime LastEscortTime
 {
  get{ return m_LastEscortTime; }
  set{ m_LastEscortTime = value; }
 }

 public PlayerMobile()
 {
  m_VisList = new ArrayList();
  m_PermaFlags = new ArrayList();
  m_AntiMacroTable = new Hashtable();

  m_BOBFilter = new Engines.BulkOrders.BOBFilter();

  m_GameTime = TimeSpan.Zero;
  m_ShortTermElapse = TimeSpan.FromHours( 8.0 );
  m_LongTermElapse = TimeSpan.FromHours( 40.0 );

  m_JusticeProtectors = new ArrayList();

  InvalidateMyRunUO();
 }

 public override bool MutateSpeech( ArrayList hears, ref string text, ref object context )
 {
  if ( Alive )
   return false;

  if ( Core.AOS )
  {
   for ( int i = 0; i < hears.Count; ++i )
   {
    object o = hears[i];

    if ( o != this && o is Mobile && ((Mobile)o).Skills[SkillName.SpiritSpeak].Value >= 100.0 )
     return false;
   }
  }

  return base.MutateSpeech( hears, ref text, ref context );
 }

 public override void Damage( int amount, Mobile from )
 {
  if ( Spells.Necromancy.EvilOmenSpell.CheckEffect( this ) )
   amount = (int)(amount * 1.25);

  Mobile oath = Spells.Necromancy.BloodOathSpell.GetBloodOath( from );

  if ( oath == this )
  {
   amount = (int)(amount * 1.1);
   from.Damage( amount, from );
  }

  base.Damage( amount, from );
 }

 public override ApplyPoisonResult ApplyPoison( Mobile from, Poison poison )
 {
  if ( !Alive )
   return ApplyPoisonResult.Immune;

  if ( Spells.Necromancy.EvilOmenSpell.CheckEffect( this ) )
   return base.ApplyPoison( from, PoisonImpl.IncreaseLevel( poison ) );

  return base.ApplyPoison( from, poison );
 }

 public PlayerMobile( Serial s ) : base( s )
 {
  m_VisList = new ArrayList();
  m_AntiMacroTable = new Hashtable();
  InvalidateMyRunUO();
 }

 public ArrayList VisibilityList
 {
  get{ return m_VisList; }
 }

 public ArrayList PermaFlags
 {
  get{ return m_PermaFlags; }
 }

 public override int Luck{ get{ return AosAttributes.GetValue( this, AosAttribute.Luck ); } }

 public override bool IsHarmfulCriminal( Mobile target )
 {
  if ( SkillHandlers.Stealing.ClassicMode && target is PlayerMobile && ((PlayerMobile)target).m_PermaFlags.Count > 0 )
  {
   int noto = Notoriety.Compute( this, target );

   if ( noto == Notoriety.Innocent )
    target.Delta( MobileDelta.Noto );

   return false;
  }

  if ( target is BaseCreature && ((BaseCreature)target).InitialInnocent )
   return false;

  return base.IsHarmfulCriminal( target );
 }

 public bool AntiMacroCheck( Skill skill, object obj )
 {
  if ( obj == null || m_AntiMacroTable == null || this.AccessLevel != AccessLevel.Player )
   return true;

  Hashtable tbl = (Hashtable)m_AntiMacroTable[skill];
  if ( tbl == null )
   m_AntiMacroTable[skill] = tbl = new Hashtable();

  CountAndTimeStamp count = (CountAndTimeStamp)tbl[obj];
  if ( count != null )
  {
   if ( count.TimeStamp + SkillCheck.AntiMacroExpire <= DateTime.Now )
   {
    count.Count = 1;
    return true;
   }
   else
   {
    ++count.Count;
    if ( count.Count <= SkillCheck.Allowance )
     return true;
    else
     return false;
   }
  }
  else
  {
   tbl[obj] = count = new CountAndTimeStamp();
   count.Count = 1;

   return true;
  }
 }

 private void RevertHair()
 {
  SetHairMods( -1, -1 );
 }

 private Engines.BulkOrders.BOBFilter m_BOBFilter;

 public Engines.BulkOrders.BOBFilter BOBFilter
 {
  get{ return m_BOBFilter; }
 }

 public override void Deserialize( GenericReader reader )
 {
  base.Deserialize( reader );
  int version = reader.ReadInt();

  switch ( version )
  {
// *****************************************************
   case 19:
   {
    m_Race = (Race)reader.ReadInt();
    goto case 18;
   }
   case 18:
   {
    m_Classe = (Classe)reader.ReadInt();
    goto case 16;
   }
// *****************************************************
   case 17: // changed how DoneQuests is serialized
   case 16:
   {
    m_Quest = QuestSerializer.DeserializeQuest( reader );

    if ( m_Quest != null )
     m_Quest.From = this;

    int count = reader.ReadEncodedInt();

    if ( count > 0 )
    {
     m_DoneQuests = new ArrayList();

     for ( int i = 0; i < count; ++i )
     {
      Type questType = QuestSerializer.ReadType( QuestSystem.QuestTypes, reader );
      DateTime restartTime;

      if ( version < 17 )
       restartTime = DateTime.MaxValue;
      else
       restartTime = reader.ReadDateTime();

      m_DoneQuests.Add( new QuestRestartInfo( questType, restartTime ) );
     }
    }

    m_Profession = reader.ReadEncodedInt();
    goto case 15;
   }
   case 15:
   {
    m_LastCompassionLoss = reader.ReadDeltaTime();
    goto case 14;
   }
   case 14:
   {
    m_CompassionGains = reader.ReadEncodedInt();

    if ( m_CompassionGains > 0 )
     m_NextCompassionDay = reader.ReadDeltaTime();

    goto case 13;
   }
   case 13: // just removed m_PayedInsurance list
   case 12:
   {
    m_BOBFilter = new Engines.BulkOrders.BOBFilter( reader );
    goto case 11;
   }
   case 11:
   {
    if ( version < 13 )
    {
     ArrayList payed = reader.ReadItemList();

     for ( int i = 0; i < payed.Count; ++i )
      ((Item)payed[i]).PayedInsurance = true;
    }

    goto case 10;
   }
   case 10:
   {
    if ( reader.ReadBool() )
    {
     m_HairModID = reader.ReadInt();
     m_HairModHue = reader.ReadInt();
     m_BeardModID = reader.ReadInt();
     m_BeardModHue = reader.ReadInt();

     // We cannot call SetHairMods( -1, -1 ) here because the items have not yet loaded
     Timer.DelayCall( TimeSpan.Zero, new TimerCallback( RevertHair ) );
    }

    goto case 9;
   }
   case 9:
   {
    SavagePaintExpiration = reader.ReadTimeSpan();

    if ( SavagePaintExpiration > TimeSpan.Zero )
    {
     BodyMod = ( Female ? 184 : 183 );
     HueMod = 0;
    }

    goto case 8;
   }
   case 8:
   {
    m_NpcGuild = (NpcGuild)reader.ReadInt();
    m_NpcGuildJoinTime = reader.ReadDateTime();
    m_NpcGuildGameTime = reader.ReadTimeSpan();
    goto case 7;
   }
   case 7:
   {
    m_PermaFlags = reader.ReadMobileList();
    goto case 6;
   }
   case 6:
   {
    NextTailorBulkOrder = reader.ReadTimeSpan();
    goto case 5;
   }
   case 5:
   {
    NextSmithBulkOrder = reader.ReadTimeSpan();
    goto case 4;
   }
   case 4:
   {
    m_LastJusticeLoss = reader.ReadDeltaTime();
    m_JusticeProtectors = reader.ReadMobileList();
    goto case 3;
   }
   case 3:
   {
    m_LastSacrificeGain = reader.ReadDeltaTime();
    m_LastSacrificeLoss = reader.ReadDeltaTime();
    m_AvailableResurrects = reader.ReadInt();
    goto case 2;
   }
   case 2:
   {
    m_Flags = (PlayerFlag)reader.ReadInt();
    goto case 1;
   }
   case 1:
   {
    m_LongTermElapse = reader.ReadTimeSpan();
    m_ShortTermElapse = reader.ReadTimeSpan();
    m_GameTime = reader.ReadTimeSpan();
    goto case 0;
   }
   case 0:
   {
    break;
   }
  }

  if ( m_PermaFlags == null )
   m_PermaFlags = new ArrayList();

  if ( m_JusticeProtectors == null )
   m_JusticeProtectors = new ArrayList();

  if ( m_BOBFilter == null )
   m_BOBFilter = new Engines.BulkOrders.BOBFilter();

  ArrayList list = this.Stabled;

  for ( int i = 0; i < list.Count; ++i )
  {
   BaseCreature bc = list[i] as BaseCreature;

   if ( bc != null )
    bc.IsStabled = true;
  }
 }
 
 public override void Serialize( GenericWriter writer )
 {
  //cleanup our anti-macro table
  foreach ( Hashtable t in m_AntiMacroTable.Values )
  {
   ArrayList remove = new ArrayList();
   foreach ( CountAndTimeStamp time in t.Values )
   {
    if ( time.TimeStamp + SkillCheck.AntiMacroExpire <= DateTime.Now )
     remove.Add( time );
   }

   for (int i=0;i<remove.Count;++i)
    t.Remove( remove[i] );
  }

  //decay our kills
  if ( m_ShortTermElapse < this.GameTime )
  {
   m_ShortTermElapse += TimeSpan.FromHours( 8 );
   if ( ShortTermMurders > 0 )
    --ShortTermMurders;
  }

  if ( m_LongTermElapse < this.GameTime )
  {
   m_LongTermElapse += TimeSpan.FromHours( 40 );
   if ( Kills > 0 )
    --Kills;
  }

  base.Serialize( writer );
 
// *****************************************************
  writer.Write( (int) 19 ); // version // anciennement 17
// *****************************************************

Vortal - September 27, 2004 06:34 AM (GMT)
Suite du PlayerMobile.cs


Scripts\Mobiles\PlayerMobile.cs
CODE
  QuestSerializer.Serialize( m_Quest, writer );

  if ( m_DoneQuests == null )
  {
   writer.WriteEncodedInt( (int) 0 );
  }
  else
  {
   writer.WriteEncodedInt( (int) m_DoneQuests.Count );

   for ( int i = 0; i < m_DoneQuests.Count; ++i )
   {
    QuestRestartInfo restartInfo = (QuestRestartInfo)m_DoneQuests[i];

    QuestSerializer.Write( (Type) restartInfo.QuestType, QuestSystem.QuestTypes, writer );
    writer.Write( (DateTime) restartInfo.RestartTime );
   }
  }

// *****************************************************
  writer.Write( (int) m_Classe );
  writer.Write( (int) m_Race );
// *****************************************************

  writer.WriteEncodedInt( (int) m_Profession );

  writer.WriteDeltaTime( m_LastCompassionLoss );

  writer.WriteEncodedInt( m_CompassionGains );

  if ( m_CompassionGains > 0 )
   writer.WriteDeltaTime( m_NextCompassionDay );

  m_BOBFilter.Serialize( writer );

  bool useMods = ( m_HairModID != -1 || m_BeardModID != -1 );

  writer.Write( useMods );

  if ( useMods )
  {
   writer.Write( (int) m_HairModID );
   writer.Write( (int) m_HairModHue );
   writer.Write( (int) m_BeardModID );
   writer.Write( (int) m_BeardModHue );
  }

  writer.Write( SavagePaintExpiration );

  writer.Write( (int) m_NpcGuild );
  writer.Write( (DateTime) m_NpcGuildJoinTime );
  writer.Write( (TimeSpan) m_NpcGuildGameTime );

  writer.WriteMobileList( m_PermaFlags, true );

  writer.Write( NextTailorBulkOrder );

  writer.Write( NextSmithBulkOrder );

  writer.WriteDeltaTime( m_LastJusticeLoss );
  writer.WriteMobileList( m_JusticeProtectors, true );

  writer.WriteDeltaTime( m_LastSacrificeGain );
  writer.WriteDeltaTime( m_LastSacrificeLoss );
  writer.Write( m_AvailableResurrects );

  writer.Write( (int) m_Flags );

  writer.Write( m_LongTermElapse );
  writer.Write( m_ShortTermElapse );
  writer.Write( this.GameTime );
 }

 public void ResetKillTime()
 {
  m_ShortTermElapse = this.GameTime + TimeSpan.FromHours( 8 );
  m_LongTermElapse = this.GameTime + TimeSpan.FromHours( 40 );
 }

 [CommandProperty( AccessLevel.GameMaster )]
 public TimeSpan GameTime
 {
  get
  {
   if ( NetState != null )
    return m_GameTime + (DateTime.Now - m_SessionStart);
   else
    return m_GameTime;
  }
 }

 public override bool CanSee( Mobile m )
 {
  if ( m is PlayerMobile && ((PlayerMobile)m).m_VisList.Contains( this ) )
   return true;

  return base.CanSee( m );
 }

 public override bool CanSee( Item item )
 {
  if ( m_DesignContext != null && m_DesignContext.Foundation.IsHiddenToCustomizer( item ) )
   return false;

  return base.CanSee( item );
 }

 #region Quest stuff
 private QuestSystem m_Quest;
 private ArrayList m_DoneQuests;

 public QuestSystem Quest
 {
  get{ return m_Quest; }
  set{ m_Quest = value; }
 }

 public ArrayList DoneQuests
 {
  get{ return m_DoneQuests; }
  set{ m_DoneQuests = value; }
 }
 #endregion

 #region MyRunUO Invalidation
 private bool m_ChangedMyRunUO;

 public bool ChangedMyRunUO
 {
  get{ return m_ChangedMyRunUO; }
  set{ m_ChangedMyRunUO = value; }
 }

 public void InvalidateMyRunUO()
 {
  if ( !Deleted && !m_ChangedMyRunUO )
  {
   m_ChangedMyRunUO = true;
   Engines.MyRunUO.MyRunUO.QueueMobileUpdate( this );
  }
 }

 public override void OnKillsChange( int oldValue )
 {
  InvalidateMyRunUO();
 }

 public override void OnGenderChanged( bool oldFemale )
 {
  InvalidateMyRunUO();
 }

 public override void OnGuildChange( Server.Guilds.BaseGuild oldGuild )
 {
  InvalidateMyRunUO();
 }

 public override void OnGuildTitleChange( string oldTitle )
 {
  InvalidateMyRunUO();
 }

 public override void OnKarmaChange( int oldValue )
 {
  InvalidateMyRunUO();
 }

 public override void OnFameChange( int oldValue )
 {
  InvalidateMyRunUO();
 }

 public override void OnSkillChange( SkillName skill, double oldBase )
 {
  InvalidateMyRunUO();
 }

 public override void OnAccessLevelChanged( AccessLevel oldLevel )
 {
  InvalidateMyRunUO();
 }

 public override void OnRawStatChange( StatType stat, int oldValue )
 {
  InvalidateMyRunUO();
 }

 public override void OnDelete()
 {
  InvalidateMyRunUO();
 }
 #endregion

 #region Fastwalk Prevention
 private static bool FastwalkPrevention = true; // Is fastwalk prevention enabled?
 private static TimeSpan FastwalkThreshold = TimeSpan.FromSeconds( 0.4 ); // Fastwalk prevention will become active after 0.4 seconds

 private DateTime m_NextMovementTime;

 public virtual bool UsesFastwalkPrevention{ get{ return ( AccessLevel < AccessLevel.GameMaster ); } }

 public virtual TimeSpan ComputeMovementSpeed( Direction dir )
 {
  if ( (dir & Direction.Mask) != (this.Direction & Direction.Mask) )
   return TimeSpan.Zero;

  bool running = ( (dir & Direction.Running) != 0 );

  bool onHorse = ( this.Mount != null );

  if ( onHorse )
   return ( running ? TimeSpan.FromSeconds( 0.1 ) : TimeSpan.FromSeconds( 0.2 ) );

  return ( running ? TimeSpan.FromSeconds( 0.2 ) : TimeSpan.FromSeconds( 0.4 ) );
 }

 public static bool MovementThrottle_Callback( NetState ns )
 {
  PlayerMobile pm = ns.Mobile as PlayerMobile;

  if ( pm == null || !pm.UsesFastwalkPrevention )
   return true;

  if ( pm.m_NextMovementTime == DateTime.MinValue )
  {
   // has not yet moved
   pm.m_NextMovementTime = DateTime.Now;
   return true;
  }

  TimeSpan ts = pm.m_NextMovementTime - DateTime.Now;

  if ( ts < TimeSpan.Zero )
  {
   // been a while since we've last moved
   pm.m_NextMovementTime = DateTime.Now;
   return true;
  }

  return ( ts < FastwalkThreshold );
 }
 #endregion

 #region Enemy of One
 private Type m_EnemyOfOneType;
 private bool m_WaitingForEnemy;

 public Type EnemyOfOneType
 {
  get{ return m_EnemyOfOneType; }
  set
  {
   Type oldType = m_EnemyOfOneType;
   Type newType = value;

   if ( oldType == newType )
    return;

   m_EnemyOfOneType = value;

   DeltaEnemies( oldType, newType );
  }
 }

 public bool WaitingForEnemy
 {
  get{ return m_WaitingForEnemy; }
  set{ m_WaitingForEnemy = value; }
 }

 private void DeltaEnemies( Type oldType, Type newType )
 {
  foreach ( Mobile m in this.GetMobilesInRange( 18 ) )
  {
   Type t = m.GetType();

   if ( t == oldType || t == newType )
    Send( new MobileMoving( m, Notoriety.Compute( this, m ) ) );
  }
 }
 #endregion

 #region Hair and beard mods
 private int m_HairModID = -1, m_HairModHue;
 private int m_BeardModID = -1, m_BeardModHue;

 public void SetHairMods( int hairID, int beardID )
 {
  if ( hairID == -1 )
   InternalRestoreHair( true, ref m_HairModID, ref m_HairModHue );
  else if ( hairID != -2 )
   InternalChangeHair( true, hairID, ref m_HairModID, ref m_HairModHue );

  if ( beardID == -1 )
   InternalRestoreHair( false, ref m_BeardModID, ref m_BeardModHue );
  else if ( beardID != -2 )
   InternalChangeHair( false, beardID, ref m_BeardModID, ref m_BeardModHue );
 }

 private Item CreateHair( bool hair, int id, int hue )
 {
  if ( hair )
   return Server.Items.Hair.CreateByID( id, hue );
  else
   return Server.Items.Beard.CreateByID( id, hue );
 }

 private void InternalRestoreHair( bool hair, ref int id, ref int hue )
 {
  if ( id == -1 )
   return;

  Item item = FindItemOnLayer( hair ? Layer.Hair : Layer.FacialHair );

  if ( item != null )
   item.Delete();

  if ( id != 0 )
   AddItem( CreateHair( hair, id, hue ) );

  id = -1;
  hue = 0;
 }

 private void InternalChangeHair( bool hair, int id, ref int storeID, ref int storeHue )
 {
  Item item = FindItemOnLayer( hair ? Layer.Hair : Layer.FacialHair );

  if ( item != null )
  {
   if ( storeID == -1 )
   {
    storeID = item.ItemID;
    storeHue = item.Hue;
   }

   item.Delete();
  }
  else if ( storeID == -1 )
  {
   storeID = 0;
   storeHue = 0;
  }

  if ( id == 0 )
   return;

  AddItem( CreateHair( hair, id, 0 ) );
 }
 #endregion

 #region Virtue stuff
 private DateTime m_LastSacrificeGain;
 private DateTime m_LastSacrificeLoss;
 private int m_AvailableResurrects;

 public DateTime LastSacrificeGain{ get{ return m_LastSacrificeGain; } set{ m_LastSacrificeGain = value; } }
 public DateTime LastSacrificeLoss{ get{ return m_LastSacrificeLoss; } set{ m_LastSacrificeLoss = value; } }
 public int AvailableResurrects{ get{ return m_AvailableResurrects; } set{ m_AvailableResurrects = value; } }

 private DateTime m_NextJustAward;
 private DateTime m_LastJusticeLoss;
 private ArrayList m_JusticeProtectors;

 public DateTime LastJusticeLoss{ get{ return m_LastJusticeLoss; } set{ m_LastJusticeLoss = value; } }
 public ArrayList JusticeProtectors{ get{ return m_JusticeProtectors; } set{ m_JusticeProtectors = value; } }

 private DateTime m_LastCompassionLoss;
 private DateTime m_NextCompassionDay;
 private int m_CompassionGains;

 public DateTime LastCompassionLoss{ get{ return m_LastCompassionLoss; } set{ m_LastCompassionLoss = value; } }
 public DateTime NextCompassionDay{ get{ return m_NextCompassionDay; } set{ m_NextCompassionDay = value; } }
 public int CompassionGains{ get{ return m_CompassionGains; } set{ m_CompassionGains = value; } }
 #endregion
}
}




Hosted for free by InvisionFree