Scripts/Engines/CannedEvil/ChampionSpawnType.cs

@@ -13,6 +13,7 @@ namespace Server.Engines.CannedEvil
 		VerminHorde,
 		UnholyTerror,
 		SleepingDragon,
+		Glade,
 		Pestilence
 	}
 
@@ -92,6 +93,13 @@ namespace Server.Engines.CannedEvil
 					new Type[]{ typeof( LesserHiryu ), typeof( RevenantLion ) },
 					new Type[]{ typeof( Hiryu ), typeof( Oni ) }
 				} ),
+				new ChampionSpawnInfo( "Glade", typeof( Twaulo ), new string[]{ "Banisher", "Enforcer", "Eradicator" } , new Type[][]
+				{																											// Glade
+					new Type[]{ typeof( Pixie ), typeof( ShadowWisp ) },
+					new Type[]{ typeof( Centaur ), typeof( MLDryad ) },
+					new Type[]{ typeof( Satyr ), typeof( CuSidhe ) },
+					new Type[]{ typeof( FerelTreefellow ), typeof( RagingGrizzlyBear ) }
+				} ),
 				new ChampionSpawnInfo( "The Corrupt", typeof( Ilhenir ), new string[]{ "Cleanser", "Expunger", "Depurator" } , new Type[][]
 				{																											// Unholy Terror
 					new Type[]{ typeof( PlagueSpawn ), typeof( Bogling ) },

Scripts/Gumps/BaseConfirmGump.cs

@@ -0,0 +1,79 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Gumps
+{
+	public class BaseConfirmGump : Gump
+	{
+		public virtual int TitleNumber{ get{ return 1075083; } } // <center>Warning!</center>
+		public virtual int LabelNumber{ get{ return 1074975; } } // Are you sure you wish to select this?
+		
+		private enum Buttons
+		{
+			Close,
+			Break,
+			Confirm
+		}
+	
+		public BaseConfirmGump() : base( 120, 50 )
+		{			
+			Closable = false;
+			Disposable = true;
+			Dragable = true;
+			Resizable = false;
+		
+			AddPage( 0 );
+			
+			AddImageTiled( 0, 0, 348, 262, 0xA8E );
+			AddAlphaRegion( 0, 0, 348, 262 );
+			AddImage( 0, 15, 0x27A8 ); 
+			AddImageTiled( 0, 30, 17, 200, 0x27A7 );
+			AddImage( 0, 230, 0x27AA ); 
+			AddImage( 15, 230, 0x280C ); 
+			AddImageTiled( 30, 0, 300, 17, 0x280A );
+			AddImage( 315, 0, 0x280E ); 
+			AddImage( 15, 244, 0x280C ); 
+			AddImageTiled( 30, 244, 300, 17, 0x280A );
+			AddImage( 315, 244, 0x280E ); 
+			AddImage( 330, 15, 0x27A8 ); 
+			AddImageTiled( 330, 30, 17, 200, 0x27A7 );
+			AddImage( 330, 230, 0x27AA ); 
+			AddImage( 333, 2, 0x2716 ); 
+			AddImage( 315, 248, 0x2716 ); 
+			AddImage( 2, 248, 0x2716 ); 
+			AddImage( 2, 2, 0x2716 ); 			
+			AddHtmlLocalized( 25, 25, 200, 20, TitleNumber, 0x7D00, false, false );
+			AddImage( 25, 40, 0xBBF ); 
+			AddHtmlLocalized( 25, 55, 300, 120, LabelNumber, 0xFFFFFF, false, false );
+			
+			AddRadio( 25, 175, 0x25F8, 0x25FB, true, (int) Buttons.Break );
+			AddRadio( 25, 210, 0x25F8, 0x25FB, false, (int) Buttons.Close );
+			
+			AddHtmlLocalized( 60, 180, 280, 20, 1074976, 0xFFFFFF, false, false );
+			AddHtmlLocalized( 60, 215, 280, 20, 1074977, 0xFFFFFF, false, false );
+			
+			AddButton( 265, 220, 0xF7, 0xF8, (int) Buttons.Confirm, GumpButtonType.Reply, 0 );
+		}
+		
+		public override void OnResponse( Server.Network.NetState state, RelayInfo info )
+		{		
+			if ( info.ButtonID == (int) Buttons.Confirm )
+			{
+				if ( info.IsSwitched( (int) Buttons.Break ) )
+					Confirm( state.Mobile );
+				else
+					Refuse( state.Mobile );
+			}
+		}
+		
+		public virtual void Confirm( Mobile from )
+		{		
+		}
+		
+		public virtual void Refuse( Mobile from )
+		{
+		}
+	}
+}

Scripts/Gumps/ConfirmBreakCrystalGump.cs

@@ -0,0 +1,53 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Gumps
+{
+	public class ConfirmBreakCrystalGump : BaseConfirmGump
+	{
+		public override int LabelNumber{ get{ return 1075084; } } // This statuette will be destroyed when its trapped creature is summoned. The creature will be bonded to you but will disappear if released. <br><br>Do you wish to proceed?
+	
+		private BaseImprisonedMobile m_Item;
+	
+		public ConfirmBreakCrystalGump( BaseImprisonedMobile item ) : base()
+		{
+			m_Item = item;
+		}
+		
+		public override void Confirm( Mobile from )
+		{			
+			if ( m_Item == null || m_Item.Deleted )
+				return;
+		
+			BaseCreature summon = m_Item.Summon;
+			
+			if ( summon != null )
+			{				
+				if ( !summon.SetControlMaster( from ) )
+					from.SendLocalizedMessage( 1049607 ); // You have too many followers to control that creature.
+				else
+				{
+					from.SendLocalizedMessage( 1049666 ); // Your pet has bonded with you!
+				
+					summon.MoveToWorld( from.Location, from.Map );
+					summon.IsBonded = true;
+					
+					summon.Skills.Wrestling.Base = 100;
+					summon.Skills.Tactics.Base = 100;
+					summon.Skills.MagicResist.Base = 100;
+					summon.Skills.Anatomy.Base = 100;
+					
+					Effects.PlaySound( summon.Location, summon.Map, summon.BaseSoundID );
+					Effects.SendLocationParticles( EffectItem.Create( summon.Location, summon.Map, EffectItem.DefaultDuration ), 0x3728, 1, 10, 0x26B6 );
+					
+					m_Item.Release( from, summon );
+					m_Item.Delete();
+				}
+			} 
+		}
+	}
+	
+	
+}

Scripts/Items/Clothing/Artifacts/CrimsonCincture.cs

@@ -0,0 +1,38 @@
+using System;
+
+namespace Server.Items
+{
+    public class CrimsonCincture : HalfApron, ITokunoDyable
+	{
+		public override int LabelNumber{ get{ return 1075043; } } // Crimson Cincture
+	
+		[Constructable]
+		public CrimsonCincture() : base()
+		{
+			Hue = 0x485;
+			
+			Attributes.BonusDex = 5;
+			Attributes.BonusHits = 10;
+			Attributes.RegenHits = 2;
+		}
+
+		public CrimsonCincture( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			
+			int version = reader.ReadInt();
+		}
+	}
+}
+

Scripts/Items/Special/8th Anniversary Items/QuiverOfInfinity.cs

@@ -26,7 +26,7 @@ namespace Server.Items
 		{
 			base.Serialize( writer );
 
-			writer.WriteEncodedInt( 0 ); //version
+			writer.WriteEncodedInt( 1 ); //version
 		}
 
 		public override void Deserialize( GenericReader reader )
@@ -34,6 +34,11 @@ namespace Server.Items
 			base.Deserialize( reader );
 
 			int version = reader.ReadEncodedInt();
+
+			if( version < 1 && DamageIncrease == 0 )
+			{
+				DamageIncrease = 10;
+			}
 		}
 	}
 }

Scripts/Items/Special/ML/GrizzledMareStatuette.cs

@@ -0,0 +1,76 @@
+using System;
+using Server;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+	public class GrizzledMareStatuette : BaseImprisonedMobile
+	{
+		public override int LabelNumber{ get{ return 1074475; } } // Grizzled Mare Statuette
+		public override BaseCreature Summon{ get { return new GrizzledMare(); } }
+	
+		[Constructable]
+		public GrizzledMareStatuette() : base( 0x2617 )
+		{
+			Weight = 1.0;
+		}
+
+		public GrizzledMareStatuette( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			
+			int version = reader.ReadInt();
+		}
+	}
+}
+
+namespace Server.Mobiles
+{
+	public class GrizzledMare : SkeletalMount
+	{	
+		public override bool DeleteOnRelease{ get{ return true; } }
+		
+		[Constructable]
+		public GrizzledMare() : base()
+		{
+			ControlSlots = 1;
+		}
+
+		public GrizzledMare( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void GetProperties( ObjectPropertyList list )
+		{
+			base.GetProperties( list );
+			
+			list.Add( 1049646 ); // (summoned)
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			
+			int version = reader.ReadInt();
+		}		
+	}
+}
+

Scripts/Items/Special/ML/MinotaurHedge.cs

@@ -0,0 +1,35 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class MinotaurHedge : Item
+	{
+	
+		[Constructable]
+		public MinotaurHedge() : base( Utility.Random( 3215, 4 ) )
+		{
+			Name = "minotaur hedge";
+			Weight = 1.0;						
+		}
+
+		public MinotaurHedge( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			
+			int version = reader.ReadInt();
+		}
+	}
+}
+

Scripts/Items/Special/ML/TormentedChains.cs

@@ -0,0 +1,35 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+	public class TormentedChains : Item
+	{
+	
+		[Constructable]
+		public TormentedChains() : base( Utility.Random( 6663, 2 ) )
+		{
+			Name = "chains of the tormented";
+			Weight = 1.0;						
+		}
+
+		public TormentedChains( Serial serial ) : base( serial )
+		{
+		}
+		
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			
+			int version = reader.ReadInt();
+		}
+	}
+}
+

Scripts/Items/Special/MonsterStatuette.cs

@@ -45,7 +45,8 @@ namespace Server.Items
 		OphidianWarrior,
 		OphidianKnight,
 		OphidianMage,
-		DreadHorn
+		DreadHorn,
+		Minotaur
 	}
 
 	public class MonsterStatuetteInfo
@@ -109,7 +110,8 @@ namespace Server.Items
 				/* OphidianWarrior */		new MonsterStatuetteInfo( 1029645, 0x25AD, 634 ),
 				/* OphidianKnight */		new MonsterStatuetteInfo( 1029642, 0x25aa, 634 ),
 				/* OphidianMage */		new MonsterStatuetteInfo( 1029643, 0x25ab, 639 ),
-				/* DreadHorn */			new MonsterStatuetteInfo( 1031651, 0x2D83, 0xA8 )
+				/* DreadHorn */			new MonsterStatuetteInfo( 1031651, 0x2D83, 0xA8 ),
+				/* Minotaur */			new MonsterStatuetteInfo( 1031657, 0x2D89, 0x596 )
 			};
 
 		public static MonsterStatuetteInfo GetInfo( MonsterStatuetteType type )

Scripts/Mobiles/Monsters/ML/Animal/RagingGrizzlyBear.cs

@@ -30,8 +30,13 @@ namespace Server.Mobiles
 			SetResistance( ResistanceType.Poison, 10, 20 );
 			SetResistance( ResistanceType.Energy, 10, 20 );
 
-			Fame = 5000;  //Guessing here
+			SetSkill( SkillName.Wrestling, 73.4, 88.1 );
-			Karma = -5000;  //Guessing here
+			SetSkill( SkillName.Tactics, 73.6, 110.5 );
+			SetSkill( SkillName.MagicResist, 32.8, 54.6 );
+			SetSkill( SkillName.Anatomy, 0, 0 );
+
+			Fame = 10000;  //Guessing here
+			Karma = 10000;  //Guessing here
 
 			VirtualArmor = 24;
 
@@ -39,8 +44,8 @@ namespace Server.Mobiles
 			
 		}
 
-		public override int Meat{ get{ return 2; } }
+		public override int Meat{ get{ return 4; } }
-		public override int Hides{ get{ return 16; } }
+		public override int Hides{ get{ return 32; } }
 		public override PackInstinct PackInstinct{ get{ return PackInstinct.Bear; } }
 
 		public RagingGrizzlyBear( Serial serial ) : base( serial )

Scripts/Mobiles/Monsters/ML/Humanoid/Melee/FerelTreefellow.cs

@@ -37,8 +37,8 @@ namespace Server.Mobiles
 			SetSkill( SkillName.Tactics, 65.1, 90.0 );// Unknown
 			SetSkill( SkillName.Wrestling, 65.1, 85.0 );// Unknown
 
-			Fame = 1000;  //Unknown
+			Fame = 12500;  //Unknown
-			Karma = -3000;  //Unknown
+			Karma = 12500;  //Unknown
 
 			VirtualArmor = 24;
 			PackItem( new Log( Utility.RandomMinMax( 23, 34 ) ) );

Scripts/Mobiles/Monsters/ML/Humanoid/Melee/Minotaur.cs

@@ -9,6 +9,11 @@ namespace Server.Mobiles
 	[CorpseName( "a minotaur corpse" )]
 	public class Minotaur : BaseCreature
 	{
+		public override WeaponAbility GetWeaponAbility()
+		{
+			return WeaponAbility.ParalyzingBlow;
+		}
+
 		[Constructable]
 		public Minotaur() : base( AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4 ) // NEED TO CHECK
 		{

Scripts/Mobiles/Monsters/ML/Humanoid/Melee/MinotaurCaptain.cs

@@ -9,6 +9,11 @@ namespace Server.Mobiles
 	[CorpseName( "a minotaur corpse" )]
 	public class MinotaurCaptain : BaseCreature
 	{
+		public override WeaponAbility GetWeaponAbility()
+		{
+			return WeaponAbility.ParalyzingBlow;
+		}
+
 		[Constructable]
 		public MinotaurCaptain() : base( AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4 ) // NEED TO CHECK
 		{

Scripts/Mobiles/Monsters/ML/Humanoid/Melee/MinotaurScout.cs

@@ -9,6 +9,10 @@ namespace Server.Mobiles
 	[CorpseName( "a minotaur corpse" )]
 	public class MinotaurScout : BaseCreature
 	{
+		public override WeaponAbility GetWeaponAbility()
+		{
+			return WeaponAbility.ParalyzingBlow;
+		}
 
 		[Constructable]
 		public MinotaurScout() : base( AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4 ) // NEED TO CHECK

Scripts/Mobiles/Monsters/ML/Humanoid/Melee/Tormented Minotaur.cs

@@ -0,0 +1,78 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+	[CorpseName( "a tormented minotaur corpse" )]
+	public class TormentedMinotaur : BaseCreature
+	{
+		public override WeaponAbility GetWeaponAbility()
+		{
+			return WeaponAbility.Dismount;
+		}
+
+		[Constructable]
+		public TormentedMinotaur() : base( AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4 )
+		{
+			Name = "Tormented Minotaur";
+			Body = 262;
+
+			SetStr( 822, 930 );
+			SetDex( 401, 415 );
+			SetInt( 128, 138 );
+
+			SetHits( 4000, 4200 );
+
+			SetDamage( 16, 30 );
+
+			SetDamageType( ResistanceType.Physical, 100 );
+
+			SetResistance( ResistanceType.Physical, 62 );
+			SetResistance( ResistanceType.Fire, 74 );
+			SetResistance( ResistanceType.Cold, 54 );
+			SetResistance( ResistanceType.Poison, 56 );
+			SetResistance( ResistanceType.Energy, 54 );
+
+			SetSkill( SkillName.Wrestling, 110.1, 111.0 );
+			SetSkill( SkillName.Tactics, 100.7, 102.8 );
+			SetSkill( SkillName.MagicResist, 104.3, 116.3 );
+
+
+			Fame = 20000;
+			Karma = -20000;
+
+		}
+
+		public override void GenerateLoot()
+		{
+			AddLoot(LootPack.FilthyRich, 10);
+		}
+
+		public override Poison PoisonImmune{ get{ return Poison.Deadly; } }
+		public override int TreasureMapLevel{ get{ return 3; } }
+
+		public override int GetDeathSound()	{ return 0x596; }
+		public override int GetAttackSound() { return 0x597; }
+		public override int GetIdleSound() { return 0x598; }
+		public override int GetAngerSound() { return 0x599; }
+		public override int GetHurtSound() { return 0x59A; }
+
+		public TormentedMinotaur( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Mobiles/Monsters/ML/Special/Ilhenir.cs

@@ -1,16 +1,20 @@
 using System;
+using System.Collections;
 using Server;
-using Server.Engines.CannedEvil;
 using Server.Items;
+using Server.Spells;
+using Server.Network;
+using System.Collections.Generic;
+using Server.Engines.CannedEvil;
 
 namespace Server.Mobiles
 {
-	[CorpseName("corpse of Ilhenir")]
+	[CorpseName("a corpse of Ilhenir")]
 	public class Ilhenir : BaseChampion
 	{
 		public override ChampionSkullType SkullType{ get{ return ChampionSkullType.Pain; } }
 
-		public override Type[] UniqueList{ get{ return new Type[] { typeof( Pacify ) }; } }
+		public override Type[] UniqueList{ get{ return new Type[] { }; } }
 		public override Type[] SharedList{ get{ return new Type[] { 	typeof( ANecromancerShroud ),
 										typeof( LieutenantOfTheBritannianRoyalGuard ),
 										typeof( OblivionsNeedle ),
@@ -20,13 +24,15 @@ namespace Server.Mobiles
 		public override MonsterStatuetteType[] StatueTypes{ get{ return new MonsterStatuetteType[] { 	MonsterStatuetteType.PlagueBeast,
 														MonsterStatuetteType.RedDeath }; } }
 
-		// Based off of the Bone Demon, since Stratics and UOGuide are lacking in info. Many things guessed for now.
 		[Constructable]
-		public Ilhenir() : base(AIType.AI_Mage)
+		public Ilhenir()
+			: base(AIType.AI_Mage)
 		{
 			Name = "Ilhenir";
 			Title = "the Stained";
-			Body = 259;
+			Body = 0x103;
+
+			BaseSoundID = 589;
 
 			SetStr( 1105, 1350 );
 			SetDex( 82, 160 );
@@ -55,10 +61,41 @@ namespace Server.Mobiles
 			SetSkill(SkillName.Tactics, 119.9);  
 			SetSkill(SkillName.Wrestling, 119.9);
 
-			Fame = 22500;
+			Fame = 50000;
-			Karma = -22500;
+			Karma = -50000;
 
 			VirtualArmor = 44;
+
+			PackResources(8);
+			PackTalismans(5);
+		}
+
+		public virtual void PackResources(int amount)
+		{
+			for (int i = 0; i < amount; i++)
+				switch (Utility.Random(6))
+				{
+					case 0: PackItem(new Blight()); break;
+					case 1: PackItem(new Scourge()); break;
+					case 2: PackItem(new Taint()); break;
+					case 3: PackItem(new Putrefication()); break;
+					case 4: PackItem(new Corruption()); break;
+					case 5: PackItem(new Muculent()); break;
+				}
+		}
+
+		public virtual void PackItems(Item item, int amount)
+		{
+			for (int i = 0; i < amount; i++)
+				PackItem(item);
+		}
+
+		public virtual void PackTalismans(int amount)
+		{
+			int count = Utility.Random(amount);
+
+			for (int i = 0; i < count; i++)
+				PackItem(new RandomTalisman());
 		}
 
 		public override void GenerateLoot()
@@ -66,10 +103,58 @@ namespace Server.Mobiles
 			AddLoot(LootPack.FilthyRich, 8);
 		}
 
+		public override void OnDeath(Container c)
+		{
+			base.OnDeath(c);
+
+			c.DropItem(new GrizzledBones());
+
+/*			if (Utility.RandomDouble() < 0.6)
+				c.DropItem(new ParrotItem()); */ //TODO Add parrots
+
+			if (Utility.RandomDouble() < 0.05)
+				c.DropItem(new GrizzledMareStatuette());
+
+			if (Utility.RandomDouble() < 0.025)
+				c.DropItem(new CrimsonCincture());
+
+/*			if (Utility.RandomDouble() < 0.05)  //TODO Add armor sets
+			{
+				switch (Utility.Random(5))
+				{
+					case 0: c.DropItem(new GrizzleGauntlets()); break;
+					case 1: c.DropItem(new GrizzleGreaves()); break;
+					case 2: c.DropItem(new GrizzleHelm()); break;
+					case 3: c.DropItem(new GrizzleTunic()); break;
+					case 4: c.DropItem(new GrizzleVambraces()); break;
+				}
+			} */
+		}
+
 		public override bool Unprovokable { get { return true; } }
 		public override bool Uncalmable { get { return true; } }
 		public override Poison PoisonImmune { get { return Poison.Lethal; } }
-		//public override int TreasureMapLevel { get { return 1; } }
+//		public override bool GivesMinorArtifact { get { return true; } } //TODO add ML minor artifacts
+		public override int TreasureMapLevel { get { return 5; } }
+
+		public override void OnGaveMeleeAttack(Mobile defender)
+		{
+			base.OnGaveMeleeAttack(defender);
+
+			if (Utility.RandomDouble() < 0.15)
+				CacophonicAttack(defender);
+		}
+
+		public override void OnDamage(int amount, Mobile from, bool willKill)
+		{
+			if (Utility.RandomDouble() < 0.15)
+				CacophonicAttack(from);
+
+			if (Utility.RandomDouble() < 0.3)
+				DropOoze();
+
+			base.OnDamage(amount, from, willKill);
+		}
 
 		public override int GetAngerSound()
 		{
@@ -95,6 +180,7 @@ namespace Server.Mobiles
 		{
 			return 0x584;
 		}
+
 		public Ilhenir(Serial serial)
 			: base(serial)
 		{
@@ -103,13 +189,275 @@ namespace Server.Mobiles
 		public override void Serialize(GenericWriter writer)
 		{
 			base.Serialize(writer);
-			writer.Write((int)0);
+
+			writer.Write((int)0); // version
 		}
 
 		public override void Deserialize(GenericReader reader)
 		{
 			base.Deserialize(reader);
+
 			int version = reader.ReadInt();
 		}
+
+		private static Hashtable m_Table;
+
+		public virtual void CacophonicAttack(Mobile to)
+		{
+			if (m_Table == null)
+				m_Table = new Hashtable();
+
+			if (to.Alive && to.Player && m_Table[to] == null)
+			{
+				to.Send(SpeedControl.WalkSpeed);
+				to.SendLocalizedMessage(1072069); // A cacophonic sound lambastes you, suppressing your ability to move.
+				to.PlaySound(0x584);
+
+				m_Table[to] = Timer.DelayCall(TimeSpan.FromSeconds(30), new TimerStateCallback(EndCacophonic_Callback), to);
+			}
+		}
+
+		private void EndCacophonic_Callback(object state)
+		{
+			if (state is Mobile)
+				CacophonicEnd((Mobile)state);
+		}
+
+		public virtual void CacophonicEnd(Mobile from)
+		{
+			if (m_Table == null)
+				m_Table = new Hashtable();
+
+			m_Table[from] = null;
+
+			from.Send(SpeedControl.Disable);
+		}
+
+		public static bool UnderCacophonicAttack(Mobile from)
+		{
+			if (m_Table == null)
+				m_Table = new Hashtable();
+
+			return m_Table[from] != null;
+		}
+
+		private DateTime m_NextDrop = DateTime.Now;
+
+		public virtual void DropOoze()
+		{
+			int amount = Utility.RandomMinMax(1, 3);
+			bool corrosive = Utility.RandomBool();
+
+			for (int i = 0; i < amount; i++)
+			{
+				Item ooze = new StainedOoze(corrosive);
+				Point3D p = new Point3D(Location);
+
+				for (int j = 0; j < 5; j++)
+				{
+					p = GetSpawnPosition(2);
+					bool found = false;
+
+					foreach (Item item in Map.GetItemsInRange(p, 0))
+						if (item is StainedOoze)
+						{
+							found = true;
+							break;
+						}
+
+					if (!found)
+						break;
+				}
+
+				ooze.MoveToWorld(p, Map);
+			}
+
+			if (Combatant != null)
+			{
+				if (corrosive)
+					Combatant.SendLocalizedMessage(1072071); // A corrosive gas seeps out of your enemy's skin!
+				else
+					Combatant.SendLocalizedMessage(1072072); // A poisonous gas seeps out of your enemy's skin!
+			}
+		}
+
+		public virtual Point3D GetSpawnPosition(int range)
+		{
+			return GetSpawnPosition(Location, Map, range);
+		}
+
+		public static Point3D GetSpawnPosition(Point3D from, Map map, int range)
+		{
+			if (map == null)
+				return from;
+
+			for (int i = 0; i < 10; i++)
+			{
+				int x = from.X + Utility.Random(range);
+				int y = from.Y + Utility.Random(range);
+				int z = map.GetAverageZ(x, y);
+
+				if (Utility.RandomBool())
+					x *= -1;
+
+				if (Utility.RandomBool())
+					y *= -1;
+
+				Point3D p = new Point3D(x, y, from.Z);
+
+				if (map.CanSpawnMobile(p) && map.LineOfSight(from, p))
+					return p;
+
+				p = new Point3D(x, y, z);
+
+				if (map.CanSpawnMobile(p) && map.LineOfSight(from, p))
+					return p;
+			}
+
+			return from;
+		}
+	}
+
+	public class StainedOoze : Item
+	{
+		private bool m_Corrosive;
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public bool Corrosive
+		{
+			get { return m_Corrosive; }
+			set { m_Corrosive = value; }
+		}
+
+		[Constructable]
+		public StainedOoze()
+			: this(false)
+		{
+		}
+
+		[Constructable]
+		public StainedOoze(bool corrosive)
+			: base(0x122A)
+		{
+			Movable = false;
+			Hue = 0x95;
+
+			m_Corrosive = corrosive;
+			Timer.DelayCall(TimeSpan.FromSeconds(30), new TimerCallback(Morph));
+		}
+
+		private Hashtable m_Table;
+
+		public override bool OnMoveOver(Mobile m)
+		{
+			if (m_Table == null)
+				m_Table = new Hashtable();
+
+			if ((m is BaseCreature && ((BaseCreature)m).Controlled) || m.Player)
+				m_Table[m] = Timer.DelayCall(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), new TimerStateCallback(Damage_Callback), m);
+
+			return base.OnMoveOver(m);
+		}
+
+		public override bool OnMoveOff(Mobile m)
+		{
+			if (m_Table == null)
+				m_Table = new Hashtable();
+
+			if (m_Table[m] is Timer)
+			{
+				Timer timer = (Timer)m_Table[m];
+
+				timer.Stop();
+
+				m_Table[m] = null;
+			}
+
+			return base.OnMoveOff(m);
+		}
+
+		public StainedOoze(Serial serial)
+			: base(serial)
+		{
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write((int)0); // version
+
+			writer.Write((bool)m_Corrosive);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			int version = reader.ReadInt();
+
+			m_Corrosive = reader.ReadBool();
+		}
+
+		private void Damage_Callback(object state)
+		{
+			if (state is Mobile)
+				Damage((Mobile)state);
+		}
+
+		public virtual void Damage(Mobile m)
+		{
+			if (!m.Alive)
+				StopTimer(m);
+
+			if (m_Corrosive)
+			{
+				for (int i = 0; i < m.Items.Count; i++)
+				{
+					IDurability item = m.Items[i] as IDurability;
+
+					if (item != null && Utility.RandomDouble() < 0.25)
+					{
+						if (item.HitPoints > 10)
+							item.HitPoints -= 10;
+						else
+							item.HitPoints -= 1;
+					}
+				}
+			}
+			else
+				AOS.Damage(m, 40, 0, 0, 0, 100, 0);
+		}
+
+		public virtual void Morph()
+		{
+			ItemID += 1;
+
+			Timer.DelayCall(TimeSpan.FromSeconds(5), new TimerCallback(Decay));
+		}
+
+		public virtual void StopTimer(Mobile m)
+		{
+			if (m_Table[m] is Timer)
+			{
+				Timer timer = (Timer)m_Table[m];
+				timer.Stop();
+				m_Table[m] = null;
+			}
+		}
+
+		public virtual void Decay()
+		{
+			if (m_Table == null)
+				m_Table = new Hashtable();
+
+			foreach (DictionaryEntry entry in m_Table)
+				if (entry.Value is Timer)
+					((Timer)entry.Value).Stop();
+
+			m_Table.Clear();
+
+			Delete();
+		}
 	}
 }

Scripts/Mobiles/Monsters/ML/Special/Meraktus.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Collections;
-using Server.Engines.CannedEvil;
+using System.Collections.Generic;
 using Server.Items;
 using Server.Targeting;
 using Server.Misc;
+using Server.Engines.CannedEvil;
 
 namespace Server.Mobiles
 {
-	[CorpseName( "a minotaur corpse" )]
+	[CorpseName( "the remains of Meraktus" )]
 	public class Meraktus : BaseChampion
 	{
 		public override ChampionSkullType SkullType{ get{ return ChampionSkullType.Pain; } }
@@ -18,16 +19,23 @@ namespace Server.Mobiles
 										typeof( ArtifactVase ),
 										typeof( MinotaurStatueDeed ) }; } }
 
-		public override MonsterStatuetteType[] StatueTypes{ get{ return new MonsterStatuetteType[] { }; } }
+		public override MonsterStatuetteType[] StatueTypes{ get{ return new MonsterStatuetteType[] { 	
+			MonsterStatuetteType.Minotaur }; } }
 
-		public override bool NoGoodies{ get{ return true; } }
+		public override WeaponAbility GetWeaponAbility()
+		{
+			return WeaponAbility.Dismount;
+		}
 
 		[Constructable]
-		public Meraktus() : base( AIType.AI_Melee )
+		public Meraktus()
+			: base(AIType.AI_Melee)
 		{
 			Name = "Meraktus";
 			Title = "the Tormented";
-			Body = 262;
+			Body = 263;
+			BaseSoundID = 680;
+			Hue = 0x835;
 
 			SetStr( 1419, 1438 );
 			SetDex( 309, 413 );
@@ -59,14 +67,57 @@ namespace Server.Mobiles
 
 			VirtualArmor = 28; // Don't know what it should be
 
-			// TODO: Area Ground Stomp: Damage + Dismount
+			PackResources(8);
+			PackTalismans(5);
+
+			Timer.DelayCall(TimeSpan.FromSeconds(1), new TimerCallback(SpawnTormented));
 		}
 
+		public virtual void PackResources(int amount)
+		{
+			for (int i = 0; i < amount; i++)
+				switch (Utility.Random(6))
+				{
+					case 0: PackItem(new Blight()); break;
+					case 1: PackItem(new Scourge()); break;
+					case 2: PackItem(new Taint()); break;
+					case 3: PackItem(new Putrefication()); break;
+					case 4: PackItem(new Corruption()); break;
+					case 5: PackItem(new Muculent()); break;
+				}
+		}
+
+		public virtual void PackTalismans(int amount)
+		{
+			int count = Utility.Random(amount);
+
+			for (int i = 0; i < count; i++)
+				PackItem(new RandomTalisman());
+		}
+
+		public override void OnDeath( Container c )
+		{
+			base.OnDeath( c );		
+
+			c.DropItem( new MalletAndChisel() );
+
+			switch ( Utility.Random( 3 ) )
+			{
+				case 0: c.DropItem( new MinotaurHedge() ); break;
+				case 1: c.DropItem( new BonePile() ); break;
+				case 2: c.DropItem( new LightYarn() ); break;
+			}
+
+			if ( Utility.RandomBool() )
+				c.DropItem( new TormentedChains() );
+
+			if ( Utility.RandomDouble() < 0.025 )
+				c.DropItem(new CrimsonCincture());
+		}
 
 		public override void GenerateLoot()
 		{
-			AddLoot( LootPack.Rich );  // Need to verify
+			AddLoot( LootPack.AosSuperBoss, 5 );  // Need to verify
-			AddLoot(LootPack.Rich);  // Need to verify
 		}
 
 		public override int GetAngerSound()
@@ -94,6 +145,61 @@ namespace Server.Mobiles
 			return 0x59c;
 		}
 
+		public override int Meat { get { return 2; } }
+		public override int Hides { get { return 10; } }
+		public override HideType HideType { get { return HideType.Regular; } }
+		public override Poison PoisonImmune{ get{ return Poison.Regular; } }
+		public override int TreasureMapLevel{ get{ return 3; } }
+		public override bool BardImmune{ get{ return true; } }
+		public override bool Unprovokable{ get{ return true; } }
+		public override bool Uncalmable { get { return true; } }
+
+		public override void OnGaveMeleeAttack(Mobile defender)
+		{
+			base.OnGaveMeleeAttack(defender);
+			if (0.2 >= Utility.RandomDouble())
+				Earthquake();
+		}
+
+		public void Earthquake()
+		{
+			Map map = this.Map;
+			if (map == null)
+				return;
+			ArrayList targets = new ArrayList();
+			foreach (Mobile m in this.GetMobilesInRange(8))
+			{
+				if (m == this || !CanBeHarmful(m))
+					continue;
+				if (m is BaseCreature && (((BaseCreature)m).Controlled || ((BaseCreature)m).Summoned || ((BaseCreature)m).Team != this.Team))
+					targets.Add(m);
+				else if (m.Player)
+					targets.Add(m);
+			}
+			PlaySound(0x2F3);
+			for (int i = 0; i < targets.Count; ++i)
+			{
+				Mobile m = (Mobile)targets[i];
+				if( m != null && !m.Deleted && m is PlayerMobile )
+				{
+					PlayerMobile pm = m as PlayerMobile;
+					if(pm != null && pm.Mounted)
+					{
+						pm.Mount.Rider=null;
+					}
+				}
+				double damage = m.Hits * 0.6;//was .6
+				if (damage < 10.0)
+					damage = 10.0;
+				else if (damage > 75.0)
+					damage = 75.0;
+				DoHarmful(m);
+				AOS.Damage(m, this, (int)damage, 100, 0, 0, 0, 0);
+				if (m.Alive && m.Body.IsHuman && !m.Mounted)
+					m.Animate(20, 7, 1, true, false, 0); // take hit
+			}
+		}
+
 		public Meraktus( Serial serial ) : base( serial )
 		{
 		}
@@ -109,5 +215,21 @@ namespace Server.Mobiles
 			base.Deserialize( reader );
 			int version = reader.ReadInt();
 		}
+		#region SpawnHelpers
+		public void SpawnTormented()
+		{
+			BaseCreature spawna = new TormentedMinotaur();
+			spawna.MoveToWorld(Location, Map);
+
+			BaseCreature spawnb = new TormentedMinotaur();
+			spawnb.MoveToWorld(Location, Map);
+
+			BaseCreature spawnc = new TormentedMinotaur();
+			spawnc.MoveToWorld(Location, Map);
+
+			BaseCreature spawnd = new TormentedMinotaur();
+			spawnd.MoveToWorld(Location, Map);
+		}
+		#endregion
 	}
 }

Scripts/Mobiles/Monsters/ML/Special/Twaulo.cs

@@ -1,15 +1,16 @@
 using System;
 using Server;
-using Server.Engines.CannedEvil;
+using System.Collections;
 using Server.Items;
+using Server.Targeting;
+using System.Collections.Generic;
+using Server.Engines.CannedEvil;
 
 namespace Server.Mobiles
 {
+	[CorpseName("a corpse of Twaulo")]
 	public class Twaulo : BaseChampion
 	{
-		// COMPLETELY guessed beyond stats. Stats/skills come from Stratics and UOGuide. No idea what the special attacks should be.
-		// Based on Silvani, due to them both using Blue creatures.
-
 		public override ChampionSkullType SkullType{ get{ return ChampionSkullType.Pain; } }
 
 		public override Type[] UniqueList{ get{ return new Type[] { typeof( Quell ) }; } }
@@ -19,12 +20,14 @@ namespace Server.Mobiles
 		public override MonsterStatuetteType[] StatueTypes{ get{ return new MonsterStatuetteType[] { MonsterStatuetteType.DreadHorn }; } }
 
 		[Constructable]
-		public Twaulo()	: base(AIType.AI_Archer, FightMode.Evil)
+		public Twaulo()
+			: base(AIType.AI_Melee)
 		{
 			Name = "Twaulo";
 			Title = "of the Glade";
 			Body = 101;
 			BaseSoundID = 679;
+			Hue = 0x455;
 
 			SetStr( 1751, 1950 );
 			SetDex( 251, 450 );
@@ -42,12 +45,14 @@ namespace Server.Mobiles
 			SetResistance( ResistanceType.Poison, 50, 60 );
 			SetResistance( ResistanceType.Energy, 50, 60 );
 
-			//Lacking OSI information skills are based on Centaurs and scaled up the way other champs are.
+			SetSkill( SkillName.EvalInt, 0 ); // Per Stratics?!?
-			SetSkill( SkillName.Anatomy, 115.1, 135.0 );
+			SetSkill( SkillName.Magery, 0 ); // Per Stratics?!?
-			SetSkill( SkillName.Archery, 100.0 );
+			SetSkill( SkillName.Meditation, 0 ); // Per Stratics?!?
-			SetSkill( SkillName.MagicResist, 100.5, 150.0 );
+			SetSkill(SkillName.Anatomy, 95.1, 115.0);
-			SetSkill( SkillName.Tactics, 100.0 );
+			SetSkill(SkillName.Archery, 95.1, 100.0);
-			SetSkill( SkillName.Wrestling, 100.0 );
+			SetSkill(SkillName.MagicResist, 50.3, 80.0);
+			SetSkill(SkillName.Tactics, 90.1, 100.0);
+			SetSkill(SkillName.Wrestling, 95.1, 100.0);
 
 			Fame = 50000;
 			Karma = 50000;
@@ -60,7 +65,9 @@ namespace Server.Mobiles
 
 		public override void GenerateLoot()
 		{
-			AddLoot( LootPack.UltraRich, 2 );
+			AddLoot(LootPack.UltraRich, 2);
+			AddLoot(LootPack.Average);
+			AddLoot(LootPack.Gems);
 		}
 
 		public override OppositionGroup OppositionGroup
@@ -71,16 +78,78 @@ namespace Server.Mobiles
 		public override bool Unprovokable{ get{ return true; } }
 		public override Poison PoisonImmune{ get{ return Poison.Regular; } }
 		public override int TreasureMapLevel{ get{ return 5; } }
+		public override int Meat { get { return 1; } }
+		public override int Hides { get { return 8; } }
+		public override HideType HideType { get { return HideType.Spined; } }
 
-		public Twaulo( Serial serial ) : base( serial )
+		public void SpawnPixies( Mobile target )
+		{
+			Map map = this.Map;
+
+			if ( map == null )
+				return;
+
+			int newPixies = Utility.RandomMinMax( 3, 6 );
+
+			for ( int i = 0; i < newPixies; ++i )
+			{
+				Pixie pixie = new Pixie();
+
+				pixie.Team = this.Team;
+				pixie.FightMode = FightMode.Closest;
+
+				bool validLocation = false;
+				Point3D loc = this.Location;
+
+				for ( int j = 0; !validLocation && j < 10; ++j )
+				{
+					int x = X + Utility.Random( 3 ) - 1;
+					int y = Y + Utility.Random( 3 ) - 1;
+					int z = map.GetAverageZ( x, y );
+
+					if ( validLocation = map.CanFit( x, y, this.Z, 16, false, false ) )
+						loc = new Point3D( x, y, Z );
+					else if ( validLocation = map.CanFit( x, y, z, 16, false, false ) )
+						loc = new Point3D( x, y, z );
+				}
+
+				pixie.MoveToWorld( loc, map );
+				pixie.Combatant = target;
+			}
+		}
+
+		public override void AlterDamageScalarFrom( Mobile caster, ref double scalar )
+		{
+			if ( 0.1 >= Utility.RandomDouble() )
+				SpawnPixies( caster );
+		}
+
+		public override void OnGaveMeleeAttack( Mobile defender )
+		{
+			base.OnGaveMeleeAttack( defender );
+
+			defender.Damage( Utility.Random( 20, 10 ), this );
+			defender.Stam -= Utility.Random( 20, 10 );
+			defender.Mana -= Utility.Random( 20, 10 );
+		}
+
+		public override void OnGotMeleeAttack( Mobile attacker )
+		{
+			base.OnGotMeleeAttack( attacker );
+
+			if ( 0.1 >= Utility.RandomDouble() )
+				SpawnPixies( attacker );
+		}
+
+		public Twaulo(Serial serial)
+			: base(serial)
 		{
 		}
 
-		public override void Serialize( GenericWriter writer )
+		public override void Serialize(GenericWriter writer)
 		{
-			base.Serialize( writer );
+			base.Serialize(writer);
-
+			writer.Write((int)0);
-			writer.Write( (int) 0 ); // version
 		}
 
 		public override void Deserialize( GenericReader reader )