context: using System;
  using Server.Mobiles;
  using Server.Multis;
  using Server.Spells;
  using Server.Targeting;
  
  namespace Server.Items
  {
      public class SpecialFishingNet : Item
      {
          private static readonly int[] m_Hues = new int[]
          {
              0x09B,
              0x0CD,
              0x0D3,
              0x14D,
              0x1DD,
              0x1E9,
              0x1F4,
              0x373,
              0x451,
              0x47F,
              0x489,
              0x492,
              0x4B5,
              0x8AA
          };
          private static readonly int[] m_WaterTiles = new int[]
          {
              0x00A8, 0x00AB,
              0x0136, 0x0137
          };
          private static readonly int[] m_UndeepWaterTiles = new int[]
          {
              0x1797, 0x179C
          };
  
          private bool m_InUse;
  
          [Constructable]
          public SpecialFishingNet()
              : base(0x0DCA)
          {
              Weight = 15.0;
  
              if (0.01 > Utility.RandomDouble())
                  Hue = Utility.RandomList(m_Hues);
              else
                  Hue = 0x8A0;
          }
  
          public SpecialFishingNet(Serial serial)
              : base(serial)
          {
          }
  
          public override int LabelNumber
          {
              get
              {
                  return 1041079;
              }
          }// a special fishing net
          [CommandProperty(AccessLevel.GameMaster)]
          public bool InUse
          {
              get
              {
                  return m_InUse;
              }
              set
              {
                  m_InUse = value;
              }
          }
          public virtual bool RequireDeepWater
          {
              get
              {
                  return true;
              }
          }
          public static bool FullValidation(Map map, int x, int y)
          {
              bool valid = ValidateDeepWater(map, x, y);
  
              for (int j = 1, offset = 5; valid && j <= 5; ++j, offset += 5)
              {
                  if (!ValidateDeepWater(map, x + offset, y + offset))
                      valid = false;
                  else if (!ValidateDeepWater(map, x + offset, y - offset))
                      valid = false;
                  else if (!ValidateDeepWater(map, x - offset, y + offset))
                      valid = false;
                  else if (!ValidateDeepWater(map, x - offset, y - offset))
                      valid = false;
              }
  
              return valid;
          }
  
          public override void GetProperties(ObjectPropertyList list)
          {
              base.GetProperties(list);
  
              AddNetProperties(list);
          }
  
          public override void Serialize(GenericWriter writer)
          {
              base.Serialize(writer);
  
              writer.Write((int)1); // version
  
              writer.Write(m_InUse);
          }
  
          public override void Deserialize(GenericReader reader)
          {
              base.Deserialize(reader);
  
              int version = reader.ReadInt();
  
              switch ( version )
              {
                  case 1:
                      {
                          m_InUse = reader.ReadBool();
  
                          if (m_InUse)
                              Delete();
  
                          break;
                      }
              }
  
              Stackable = false;
          }
  
          public override void OnDoubleClick(Mobile from)
          {
              if (m_InUse)
              {
                  from.SendLocalizedMessage(1010483); // Someone is already using that net!
              }
              else if (IsChildOf(from.Backpack))
              {
                  from.SendLocalizedMessage(1010484); // Where do you wish to use the net?
                  from.BeginTarget(-1, true, TargetFlags.None, new TargetCallback(OnTarget));
              }
              else
              {
                  from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
              }
          }
  
          public void OnTarget(Mobile from, object obj)
          {
              if (Deleted || m_InUse)
                  return;
  
              IPoint3D p3D = obj as IPoint3D;
  
              if (p3D == null)
                  return;
  
              Map map = from.Map;
  
              if (map == null || map == Map.Internal)
                  return;
  
              int x = p3D.X, y = p3D.Y, z = map.GetAverageZ(x, y); // OSI just takes the targeted Z
  
              if (!from.InRange(p3D, 6))
              {
                  from.SendLocalizedMessage(500976); // You need to be closer to the water to fish!
              }
              else if (!from.InLOS(obj))
              {
                  from.SendLocalizedMessage(500979); // You cannot see that location.
              }
              else if (RequireDeepWater ? FullValidation(map, x, y) : (ValidateDeepWater(map, x, y) || ValidateUndeepWater(map, obj, ref z)))
              {
                  Point3D p = new Point3D(x, y, z);
  
                  if (GetType() == typeof(SpecialFishingNet))
                  {
                      for (int i = 1; i < Amount; ++i) // these were stackable before, doh
                          from.AddToBackpack(new SpecialFishingNet());
                  }
  
                  m_InUse = true;
                  Movable = false;
                  MoveToWorld(p, map);
  
                  SpellHelper.Turn(from, p);
  
                  if (Core.SA)
                  {
                      from.Animate(AnimationType.Attack, 6);
                  }
                  else
                  {
                      from.Animate(12, 5, 1, true, false, 0);
                  }
  
                  Effects.SendLocationEffect(p, map, 0x352D, 16, 4);
                  Effects.PlaySound(p, map, 0x364);
  
                  Timer.DelayCall(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(1.25), 14, new TimerStateCallback(DoEffect), new object[] { p, 0, from });
  
                  from.SendLocalizedMessage(RequireDeepWater ? 1010487 : 1074492); // You plunge the net into the sea... / You plunge the net into the water...
              }
              else
              {
                  from.SendLocalizedMessage(RequireDeepWater ? 1010485 : 1074491); // You can only use this net in deep water! / You can only use this net in water!
              }
          }
  
          protected virtual void AddNetProperties(ObjectPropertyList list)
          {
              // as if the name wasn't enough..
              list.Add(1017410); // Special Fishing Net
          }
  
          protected virtual int GetSpawnCount()
          {
              int count = Utility.RandomMinMax(3, 6);
  
              if (Hue != 0x8A0)
                  count += Utility.RandomMinMax(1, 2);
  
              return count;
          }
  
          protected void Spawn(Point3D p, Map map, BaseCreature spawn)
          {
              if (map == null)
              {
                  spawn.Delete();
                  return;
              }
  
              int x = p.X, y = p.Y;
  
              for (int j = 0; j < 20; ++j)
              {
                  int tx = p.X - 2 + Utility.Random(5);
                  int ty = p.Y - 2 + Utility.Random(5);
  
                  LandTile t = map.Tiles.GetLandTile(tx, ty);
  
                  if (t.Z == p.Z && ((t.ID >= 0xA8 && t.ID <= 0xAB) || (t.ID >= 0x136 && t.ID <= 0x137)) && !Spells.SpellHelper.CheckMulti(new Point3D(tx, ty, p.Z), map))
                  {
                      x = tx;
                      y = ty;
                      break;
                  }
              }
  
              spawn.MoveToWorld(new Point3D(x, y, p.Z), map);
  
              if (spawn is Kraken && 0.35 < Utility.RandomDouble())
                  spawn.PackItem(new MessageInABottle(map == Map.Felucca ? Map.Felucca : Map.Trammel));
              
          }
  
          protected virtual void FinishEffect(Point3D p, Map map, Mobile from)
          {
              from.RevealingAction();
  
              int count = GetSpawnCount();
  
  
gt:             for (int i = 0; map != null && i < count; ++i)