Example #1
0
		public static void Fill( Container c, int itemCount, double talismanChance )
		{
			c.Hue = Utility.RandomNondyedHue();

			int done = 0;

			if ( Utility.RandomDouble() < talismanChance )
			{
				c.DropItem( new RandomTalisman() );
				++done;
			}

			for ( ; done < itemCount; ++done )
			{
				Item loot = null;

				switch ( Utility.Random( 5 ) )
				{
					case 0: loot = Loot.RandomWeapon( false, true ); break;
					case 1: loot = Loot.RandomArmor( false, true ); break;
					case 2: loot = Loot.RandomRangedWeapon( false, true ); break;
					case 3: loot = Loot.RandomJewelry(); break;
					case 4: loot = Loot.RandomHat( false ); break;
				}

				if ( loot == null )
					continue;

				Enhance( loot );
				c.DropItem( loot );
			}
		}
Example #2
0
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );	
			
			c.DropItem( new EyeOfTheTravesty() );
			c.DropItem( new OrdersFromMinax() );
			
			switch ( Utility.Random( 3 ) )
			{
				case 0: c.DropItem( new TravestysSushiPreparations() ); break;
				case 1: c.DropItem( new TravestysFineTeakwoodTray() ); break;
				case 2: c.DropItem( new TravestysCollectionOfShells() ); break;
			}
			
			if ( Utility.RandomDouble() < 0.6 )				
				c.DropItem( new ParrotItem() );
			
			if ( Utility.RandomDouble() < 0.1 )
				c.DropItem( new TragicRemainsOfTravesty() );
				
			if ( Utility.RandomDouble() < 0.05 )
				c.DropItem( new ImprisonedDog() );
				
			if ( Utility.RandomDouble() < 0.05 )
				c.DropItem( new MarkOfTravesty() );
				
			if ( Utility.RandomDouble() < 0.025 )
				c.DropItem( new CrimsonCincture() );
		}
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );

			c.DropItem( new DiseasedBark() );
			c.DropItem( new EternallyCorruptTree() );

			int drop = Utility.Random( 2, 4 );

			for ( int i = 0; i < drop; i++ )
				c.DropItem( new MelisandesFermentedWine() );

			if ( Utility.RandomDouble() < 0.6 )
				c.DropItem( new ParrotItem() );

			if ( Utility.RandomDouble() < 0.2225 )
			{
				switch ( Utility.Random( 3 ) )
				{
					case 0: c.DropItem( new MelisandesHairDye() ); break;
					case 1: c.DropItem( new MelisandesCorrodedHatchet() ); break;
					case 2: c.DropItem( new AlbinoSquirrelImprisonedInCrystal() ); break;
				}
			}

			if ( Utility.RandomDouble() < 0.05 )
				c.DropItem( new MyrmidonLegs() );

			if ( Utility.RandomDouble() < 0.025 )
				c.DropItem( new CrimsonCincture() );
		}
Example #4
0
		public override void OnDeath(Container c)
		{
			base.OnDeath(c);

			if (Utility.RandomDouble() < 0.20)
			{
				switch (Utility.Random(4))
				{
					case 0:
						c.DropItem(new EssenceDiligence());
						break;
					case 1:
						c.DropItem(new FairyDragonWing());
						break;
					case 2:
						c.DropItem(new FaeryDust());
						break;
					case 3:
						c.DropItem(new FeyWings());
						break;
				}

				if (Utility.RandomDouble() < 0.30)
				{
					c.DropItem(new DraconicOrbKeyBlue());
				}
			}
		}
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            c.DropItem(new DragonBlood(6));
            c.DropItem(new GargishStoneArms());
        }
        public override void OnDeath(Container c)
        {

            base.OnDeath(c);
            Region reg = Region.Find(c.GetWorldLocation(), c.Map);
            if (0.25 > Utility.RandomDouble() && reg.Name == "Fairy Dragon Lair")
            {
                switch (Utility.Random(2))
                {
                    case 0: c.DropItem(new EssenceDiligence()); break;
                    case 1: c.DropItem(new FaeryDust()); break;
                }
            }
            if (Utility.RandomDouble() <= 0.25)
            {
                switch (Utility.Random(2))
                {
                    case 0:
                        c.DropItem(new FeyWings());
                        break;
                    case 1:
                        c.DropItem(new FairyDragonWing());
                        break;

                }
            }

            if (Utility.RandomDouble() < 0.10)
            {
                c.DropItem(new DraconicOrb());

            }
        }
Example #7
0
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );

            c.DropItem( new Gold(1500));
            c.DropItem( new Bandage(12));
        }
        public override void OnDeath(Container c)
        {
            if (Utility.RandomDouble() <= 0.1)
            {
                c.DropItem(new BlindingAnkh());
            }

            if (Utility.RandomDouble() <= 0.01)
            {
                c.DropItem(new DaemonBlood{Hue = 33, Name = "Daemon Ichor"});
            }

            if (Utility.RandomDouble() <= 0.001)
            {
                if (Utility.RandomBool())
                {
                    c.DropItem(new BloodSpear {Hue = 33});
                }
                else
                {
                    c.DropItem(new BloodFork { Hue = 33 });
                }
            }
            base.OnDeath(c);
        }
		public override void OnDeath( Container c )
		{
			if ( Utility.Random( 35 ) < 1 )
			{
				DecemberDeed deed = new DecemberDeed();
				deed.Hue = 2006;
				deed.Name = "a deed from the Grinch";
				deed.Movable = true;
				deed.Weight = 5.0;
				c.DropItem( deed );
			}

            		int cnt = 1;
            		if ( Utility.Random( 4 ) < 1 ) cnt++;
            		if ( Utility.Random( 5 ) < 1 ) cnt++;

            		for (int i = 0; i < cnt; ++i)
            		{
                		switch (Utility.Random(4))
                		{
                    			case 0: c.DropItem( new SpecialHairDye() ); break;
                    			case 1: c.DropItem( new SpecialBeardDye() ); break;
                    			case 2: c.DropItem( new ClothingBlessDeed() ); break;
                    			case 3: c.DropItem( new NameChangeDeed() ); break;
                		}
            		}
			base.OnDeath( c );
		}
Example #10
0
        public override void OnDeath(Container c)
        {

            base.OnDeath(c);
            Region reg = Region.Find(c.GetWorldLocation(), c.Map);
            if (1.0 > Utility.RandomDouble() && reg.Name == "Crimson Veins")
            {
                if (Utility.RandomDouble() < 0.6)
                    c.DropItem(new EssencePrecision());
                if (Utility.RandomDouble() < 0.6)
                    c.DropItem(new DaemonClaw());
            }

            if (1.0 > Utility.RandomDouble() && reg.Name == "Fire Temple Ruins")
            {
                if (Utility.RandomDouble() < 0.6)
                    c.DropItem(new EssenceOrder());
                if (Utility.RandomDouble() < 0.6)
                    c.DropItem(new DaemonClaw());
            }
            if (1.0 > Utility.RandomDouble() && reg.Name == "Lava Caldera")
            {
                if (Utility.RandomDouble() < 0.6)
                    c.DropItem(new EssencePassion());
                if (Utility.RandomDouble() < 0.6)
                    c.DropItem(new DaemonClaw());
            }
        }
Example #11
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.05)
            {
                switch (Utility.Random(2))
                {
                    case 0:
                        c.DropItem(new SlithTongue());
                        break;
                    case 1:
                        c.DropItem(new SlithEye());
                        break;
                }
            }

            if (Utility.RandomDouble() < 0.25)
            {
                switch (Utility.Random(2))
                {
                    case 0:
                        c.DropItem(new AncientPotteryFragments());
                        break;
                    case 1:
                        c.DropItem(new TatteredAncientScroll());
                        break;
                }
            }
        }
Example #12
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.10)
            {
                switch (Utility.Random(2))
                {
                    case 0: c.DropItem(new EssenceDiligence()); break;

                    case 1: c.DropItem(new FairyDragonWing()); break;
                }

                if (Utility.RandomDouble() < 0.10)
                {
                    switch (Utility.Random(2))
                    {
                        case 0: c.DropItem(new DraconicOrbKey()); break;

                        case 1: c.DropItem(new UntransTome()); break;
                    }
                }

                if (Utility.RandomDouble() < 0.05)
                {
                   
                        c.DropItem(new AnimatedLegsoftheInsaneTinker()); 
                }
            }
        }
Example #13
0
 public override void OnDeath(Container c)
 {
     base.OnDeath(c);
     var reg = Region.Find(c.GetWorldLocation(), c.Map);
     if (0.4 > Utility.RandomDouble() && reg.Name == "Ariel Writ Disaster")
         c.DropItem(new ArielHavenWritofMembership());
     c.DropItem(new BonePile());
 }
Example #14
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);	
			
                c.DropItem(new DragonFlameKey());

            if (Utility.RandomDouble() < 0.5)
                c.DropItem(new DragonFlameSectBadge());
        }
Example #15
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            c.DropItem(new AbscessTail());

            if (Paragon.ChestChance > Utility.RandomDouble())
                c.DropItem(new ParagonChest(Name, TreasureMapLevel));
        }
Example #16
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            c.DropItem(new SalivasFeather());

            if (Utility.RandomDouble() < 0.1)
                c.DropItem(new ParrotItem());
        }
Example #17
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.25)
                c.DropItem(new ShatteredCrystals());

            c.DropItem(new CrystallineFragments());
        }
Example #18
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);	
			
                c.DropItem(new TigerClawKey());

            if (Utility.RandomDouble() < 0.5)
                c.DropItem(new TigerClawSectBadge());
        }
Example #19
0
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );

			if ( Utility.RandomDouble() < 0.3 )
				c.DropItem( new PixieLeg() );

			if ( Utility.RandomDouble() <= 0.01 ) // 1% chance
				c.DropItem( new AngelSnack() );
		}
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );		
			
			if ( Utility.RandomDouble() < 0.75 )
				c.DropItem( new CrystallineFragments() );
				
			if ( Utility.RandomDouble() < 0.07 )
				c.DropItem( new PiecesOfCrystal() );
		}
Example #21
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.10)
                c.DropItem(new VoidOrb());

            if (Utility.RandomDouble() < 0.20)
                c.DropItem(new VoidEssence());
        }
		public override void OnDeath( Container c )
   		{
   			if (Utility.Random( 150 ) <  1 )
   			c.DropItem( new OrcishBannerEastDeed() );
			
			if (Utility.Random( 150 ) <  1 )
   			c.DropItem( new OrcishBannerSouthDeed() );

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

            if (Utility.RandomDouble() < 0.15)
                c.DropItem(new GoblinBlood());

            if (Utility.RandomDouble() < 0.1)
                c.DropItem(new EssenceControl());
        }
		public override void OnDeath( Container c )
		{
			if ( Utility.Random( 70 ) < 1 )
			c.DropItem( new RainbowSpiderStatue() );

			if ( Utility.Random( 35 ) < 1 )
			c.DropItem( new AugustBook() );

			base.OnDeath( c );
		}
Example #25
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.15)
                c.DropItem(new DisintegratingThesisNotes());

            if (Utility.RandomDouble() < 0.1)
                c.DropItem(new ParrotItem());
        }
		public override void OnDeath( Container c )
		{
			if ( Utility.Random( 50 ) < 1 )
			c.DropItem( new HalloweenCandle() );

			if ( Utility.Random( 10 ) < 1 )
			c.DropItem( new HalloweenStatue() );

			base.OnDeath( c );
		}
Example #27
0
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );		
			
			if ( Utility.RandomDouble() < 0.6 )
				c.DropItem( new BrokenCrystals() );
				
			if ( Utility.RandomDouble() < 0.1 )				
				c.DropItem( new ParrotItem() );
		}
Example #28
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.15)
                c.DropItem(new DisintegratingThesisNotes());

            if (Paragon.ChestChance > Utility.RandomDouble())
                c.DropItem(new ParagonChest(Name, TreasureMapLevel));
        }
Example #29
0
		public override void OnDeath( Container c )
		{
			base.OnDeath( c );		
			
			if ( Utility.RandomDouble() < 0.25 )
				c.DropItem( new IrksBrain() );
				
			if ( Utility.RandomDouble() < 0.025 )
				c.DropItem( new PaladinGloves() );
		}
Example #30
0
        public override void OnDeath(Container c)
        {
            base.OnDeath(c);

            if (Utility.RandomDouble() < 0.03)            
                c.DropItem(new LuckyCoin());
           
            if (Utility.RandomDouble() < 0.15)
                c.DropItem(new BottleIchor());
        }
Example #31
0
        protected override void OnAfterDeath(Server.Items.Container c)
        {
            if (Utility.RandomBool())
            {
                c.DropItem(new Engines.MLQuests.CoilsFang());
            }

            if (2000 > Utility.Random(100000))
            {
                c.DropItem(SetItemsHelper.GetRandomSetItem());
            }

            base.OnAfterDeath(c);
        }
Example #32
0
        public override void OnDoubleClick(Mobile from)
        {
            if (!from.InLOS(this.GetWorldLocation()))
            {
                from.SendLocalizedMessage(502800);                   // You can't see that.
                return;
            }

            if (from.GetDistanceToSqrt(this.GetWorldLocation()) > 4)
            {
                from.SendLocalizedMessage(500446);                   // That is too far away.
                return;
            }

            from.SendMessage("You have been given some supplies based on your skills.");

            //4 pouches
            for (int i = 0; i < 4; ++i)
            {
                Pouch p = new Pouch();
                p.TrapType  = TrapType.MagicTrap;
                p.TrapPower = 1;
                p.Hue       = 0x25;
                PackItem(from, p);
            }

            if (from.Skills[SkillName.Magery].Value >= 50.0)
            {
                GiveLeatherArmor(from);
            }
            else
            {
                GiveBoneArmor(from);
            }

            if (from.Skills[SkillName.Magery].Value >= 50.0)
            {
                PackItem(from, new BagOfReagents());
            }

            if (from.Skills[SkillName.Healing].Value >= 50.0)
            {
                PackItem(from, new Bandage(100));
            }

            if (from.Skills[SkillName.Fencing].Value >= 50.0)
            {
                PackItem(from, new ShortSpear());
                if (from.Skills[SkillName.Parry].Value >= 50.0)
                {
                    GiveItem(from, new Kryss());
                    GiveItem(from, new MetalKiteShield());
                }
                else
                {
                    GiveItem(from, new Spear());
                }
            }

            if (from.Skills[SkillName.Swords].Value >= 50.0)
            {
                if (from.Skills[SkillName.Parry].Value >= 50.0)
                {
                    GiveItem(from, new MetalKiteShield());
                }

                GiveItem(from, new Katana());
                GiveItem(from, new Halberd());
            }

            if (from.Skills[SkillName.Macing].Value >= 50.0)
            {
                if (from.Skills[SkillName.Parry].Value >= 50.0)
                {
                    GiveItem(from, new MetalKiteShield());
                }
                GiveItem(from, new WarAxe());
                GiveItem(from, new WarHammer());
            }

            if (from.Skills[SkillName.Archery].Value >= 50.0)
            {
                GiveItem(from, new HeavyCrossbow());
                GiveItem(from, new Crossbow());
                GiveItem(from, new Bow());

                PackItem(from, new Bolt(100));
                PackItem(from, new Arrow(100));
            }

            if (from.Skills[SkillName.Poisoning].Value >= 50.0)
            {
                for (int i = 0; i < 5; i++)
                {
                    PackItem(from, new GreaterPoisonPotion());
                }
            }

            PlayerMobile pm = (PlayerMobile)(from);

            Container bag      = new Bag();
            Container backpack = pm.Backpack;

            for (int i = 0; i < 20; i++)
            {
                GreaterCurePotion cure = new GreaterCurePotion();
                bag.DropItem(cure);
            }

            for (int i = 0; i < 20; i++)
            {
                GreaterHealPotion heal = new GreaterHealPotion();
                bag.DropItem(heal);
            }

            for (int i = 0; i < 20; i++)
            {
                TotalRefreshPotion refresh = new TotalRefreshPotion();
                bag.DropItem(refresh);
            }

            backpack.DropItem(bag);
        }
Example #33
0
            protected override void OnTarget(Mobile from, object targeted)
            {
                Item target = ((Item)targeted);

                Container pack = from.Backpack;

                if (pack == null)
                {
                    from.SendMessage("Please ensure you have a pack.");
                    return;
                }

                if (target == null || target.Deleted || !(target is Runebook) || ((Runebook)target).Entries.Count > 0)
                {
                    from.SendMessage("You can only copy to an empty runebook.");
                    return;
                }

                if (target.RootParent != from)
                {
                    from.SendMessage("The runebook you wish to write to must be in your backpack.");
                    return;
                }

                if (ConsumeTotal(pack, ((Runebook)m_Source).Entries.Count, true) > -1)
                {
                    from.SendMessage("This operation requires unmarked recall runes and mark scrolls.");
                    from.SendMessage("Total of each needed: {0}.", ((Runebook)m_Source).Entries.Count);
                    return;
                }

                Type t = typeof(Runebook);

                ConstructorInfo c = t.GetConstructor(Type.EmptyTypes);

                if (c != null)
                {
                    try
                    {
                        from.SendMessage("Writing Copy...");

                        object o = c.Invoke(null);

                        if (o != null && o is Item)
                        {
                            Item newItem = (Item)o;
                            Dupe.CopyProperties(newItem, m_Source);
                            m_Source.OnAfterDuped(newItem);
                            newItem.Parent = null;
                            pack.DropItem(newItem);

                            newItem.InvalidateProperties();
                            from.SendMessage("Done");
                            m_Pen.UsesRemaining -= 1;
                            m_Pen.InvalidateProperties();
                            target.Delete();
                        }
                    }
                    catch
                    {
                        from.SendMessage("Error, please notify a GM!");
                    }
                }
            }
        public void Spawn(int index)
        {
            if (m_ItemsName.Count == 0 || index >= m_ItemsName.Count || m_Container == null)
            {
                return;
            }

            Defrag();

            // random means spawn N random items from the list
            // Note RandomItem is ignored when the spawner type is ChestLootPackSpawner
            if (m_RandomItem == false && this is ChestLootPackSpawner == false)
            {                   // See if we have reached the limit at for this type of item
                if (CountItems((string)m_ItemsName[index]) >= m_Count)
                {
                    return;
                }
            }
            // otherwise spawn N of everything in the list
            else
            {                   // See if we have reached the limit at for this type of item
                if (m_Items.Count >= m_Count)
                {
                    return;
                }
            }

            if (m_ChanceToSpawn >= Utility.RandomDouble())
            {
                Type type = SpawnerType.GetType((string)m_ItemsName[index]);

                if (type != null)
                {
                    try
                    {
                        object o = Activator.CreateInstance(type);

                        if (o is Item)
                        {
                            if (m_Container != null)
                            {
                                Item item = (Item)o;
                                m_Items.Add(item);                                              //add it to the list
                                InvalidateProperties();
                                Container cont = m_Container;                                   //spawn it in the container
                                cont.DropItem(item);
                            }
                        }
                    }
                    catch (Exception ex) { EventSink.InvokeLogException(new LogExceptionEventArgs(ex)); }
                }

                Item lootPack = ChestItemSpawnerType.GetLootPack((string)m_ItemsName[index]);

                if (lootPack != null)
                {
                    try
                    {
                        ArrayList o = CreateItem(lootPack);

                        if (o != null && o.Count > 0)
                        {
                            if (m_Container != null)
                            {
                                for (int ix = 0; ix < o.Count; ix++)
                                {
                                    Item item = o[ix] as Item;
                                    m_Items.Add(item);                                                  //add it to the list
                                    InvalidateProperties();
                                    Container cont = m_Container;                                       //spawn it in the container
                                    cont.DropItem(item);
                                }
                            }
                        }
                    }
                    catch (Exception ex) { EventSink.InvokeLogException(new LogExceptionEventArgs(ex)); }
                }
            }
        }
Example #35
0
        public override void OnHit(Mobile attacker, Mobile defender, int damage)
        {
            if (!this.Validate(attacker))
            {
                return;
            }

            ClearCurrentAbility(attacker);

            Item toDisarm = defender.FindItemOnLayer(Layer.OneHanded);

            if (toDisarm == null || !toDisarm.Movable)
            {
                toDisarm = defender.FindItemOnLayer(Layer.TwoHanded);
            }

            Container pack = defender.Backpack;

            if (pack == null || (toDisarm != null && !toDisarm.Movable))
            {
                attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
            }
            else if (toDisarm == null || toDisarm is BaseShield || toDisarm is Spellbook && !Core.ML)
            {
                attacker.SendLocalizedMessage(1060849); // Your target is already unarmed!
            }
            else if (this.CheckMana(attacker, true))
            {
                // Skill Masteries - removed publish 96

                /*int saveChance = Server.Spells.SkillMasteries.MasteryInfo.SavingThrowChance(defender);
                 *
                 * if (saveChance > 0 && saveChance >= Utility.Random(100))
                 * {
                 *  attacker.SendLocalizedMessage(1156033); // Your disarm attempt was blocked!
                 *  defender.SendLocalizedMessage(1156034); // You blocked a disarm attempt!
                 *  return;
                 * }*/

                attacker.SendLocalizedMessage(1060092); // You disarm their weapon!
                defender.SendLocalizedMessage(1060093); // Your weapon has been disarmed!

                defender.PlaySound(0x3B9);
                defender.FixedParticles(0x37BE, 232, 25, 9948, EffectLayer.LeftHand);

                pack.DropItem(toDisarm);

                BuffInfo.AddBuff(defender, new BuffInfo(BuffIcon.NoRearm, 1075637, BlockEquipDuration, defender));

                BaseWeapon.BlockEquip(defender, BlockEquipDuration);

                if (defender is BaseCreature && ((BaseCreature)defender).AutoRearms)
                {
                    Timer.DelayCall(BlockEquipDuration + TimeSpan.FromSeconds(Utility.RandomMinMax(3, 10)), () =>
                    {
                        if (toDisarm != null && !toDisarm.Deleted && toDisarm.IsChildOf(defender.Backpack))
                        {
                            defender.EquipItem(toDisarm);
                        }
                    });
                }
            }
        }
Example #36
0
        public override void OnHit(Mobile attacker, Mobile defender, int damage)
        {
            if (!Validate(attacker))
            {
                return;
            }

            if (attacker is TeiravonMobile && defender is TeiravonMobile)
            {
                TeiravonMobile tmd    = (TeiravonMobile)defender;
                TeiravonMobile tma    = (TeiravonMobile)attacker;
                int            dlevel = tmd.PlayerLevel;
                int            alevel = tma.PlayerLevel;
                int            adj    = (dlevel - alevel) * 3;
                if (Utility.Random(100) < 50 + adj)
                {
                    ClearCurrentAbility(attacker);
                    attacker.SendMessage("Your disarm attempt fails.");
                    return;
                }
            }
            else if (attacker is TeiravonMobile && defender is BaseCreature)
            {
                BaseCreature   tmd    = (BaseCreature)defender;
                TeiravonMobile tma    = (TeiravonMobile)attacker;
                int            dlevel = tmd.Level;
                int            alevel = tma.PlayerLevel;
                int            adj    = (dlevel - alevel) * 3;
                if (Utility.Random(100) < 50 + adj)
                {
                    ClearCurrentAbility(attacker);
                    defender.Say("Nice try, fiend!");
                    return;
                }
            }

            ClearCurrentAbility(attacker);

            Item toDisarm = defender.FindItemOnLayer(Layer.OneHanded);

            if (toDisarm == null || !toDisarm.Movable)
            {
                toDisarm = defender.FindItemOnLayer(Layer.TwoHanded);
            }

            Container pack = defender.Backpack;

            if (pack == null || (toDisarm != null && !toDisarm.Movable))
            {
                attacker.SendLocalizedMessage(1004001);                   // You cannot disarm your opponent.
            }
            else if (toDisarm == null || toDisarm is BaseShield)
            {
                attacker.SendLocalizedMessage(1060849);                   // Your target is already unarmed!
            }
            else if (CheckMana(attacker, true))
            {
                attacker.SendLocalizedMessage(1060092);                   // You disarm their weapon!
                defender.SendLocalizedMessage(1060093);                   // Your weapon has been disarmed!

                defender.PlaySound(0x3B9);
                defender.FixedParticles(0x37BE, 232, 25, 9948, EffectLayer.LeftHand);

                pack.DropItem(toDisarm);

                BaseWeapon.BlockEquip(defender, BlockEquipDuration);

                if (defender is BaseCreature)
                {
                    Timer timer = new RearmTimer(defender);
                    timer.Start();
                }
            }
        }
Example #37
0
            protected override void OnTarget(Mobile from, object targeted)
            {
                if (from == targeted)
                {
                    from.SendMessage("Possess yourself? Hmm, interesting concept.");
                }
                else if (targeted is Mobile) // we only possess mobiles. If you want to possess a house, find another script
                {
                    if (targeted is PlayerMobile)
                    {
                        from.SendMessage("You can't possess a player. They are already possessed by Satan.");
                    }
                    else
                    {
                        ps.m_Possessed = targeted as Mobile;

                        // take everything off and put it in a white backpack
                        ps.m_Stuff     = new Backpack();
                        ps.m_Stuff.Hue = 1153;
                        Container packy = from.Backpack;
                        packy.DropItem(ps.m_Stuff);

                        RemoveLayer(from, Layer.FirstValid, ps.m_Stuff);
                        RemoveLayer(from, Layer.TwoHanded, ps.m_Stuff);
                        RemoveLayer(from, Layer.OneHanded, ps.m_Stuff);
                        // wing layer on my shard
                        RemoveLayer(from, Layer.Unused_xF, ps.m_Stuff);
                        RemoveLayer(from, Layer.Shoes, ps.m_Stuff);
                        RemoveLayer(from, Layer.Pants, ps.m_Stuff);
                        RemoveLayer(from, Layer.Shirt, ps.m_Stuff);
                        RemoveLayer(from, Layer.Helm, ps.m_Stuff);
                        RemoveLayer(from, Layer.Gloves, ps.m_Stuff);
                        RemoveLayer(from, Layer.Ring, ps.m_Stuff);
                        RemoveLayer(from, Layer.Neck, ps.m_Stuff);
                        RemoveLayer(from, Layer.Hair, ps.m_Stuff);
                        RemoveLayer(from, Layer.Waist, ps.m_Stuff);
                        RemoveLayer(from, Layer.InnerTorso, ps.m_Stuff);
                        RemoveLayer(from, Layer.Bracelet, ps.m_Stuff);
                        RemoveLayer(from, Layer.FacialHair, ps.m_Stuff);
                        RemoveLayer(from, Layer.MiddleTorso, ps.m_Stuff);
                        RemoveLayer(from, Layer.Earrings, ps.m_Stuff);
                        RemoveLayer(from, Layer.Arms, ps.m_Stuff);
                        RemoveLayer(from, Layer.Cloak, ps.m_Stuff);
                        RemoveLayer(from, Layer.OuterTorso, ps.m_Stuff);
                        RemoveLayer(from, Layer.OuterLegs, ps.m_Stuff);
                        RemoveLayer(from, Layer.LastUserValid, ps.m_Stuff);

                        // now copy everything from the mobile you are possessing and equip it
                        CopyLayer(ps.m_Possessed, from, Layer.FirstValid);
                        CopyLayer(ps.m_Possessed, from, Layer.TwoHanded);
                        CopyLayer(ps.m_Possessed, from, Layer.OneHanded);
                        // wing layer on my shard
                        CopyLayer(ps.m_Possessed, from, Layer.Unused_xF);
                        CopyLayer(ps.m_Possessed, from, Layer.Shoes);
                        CopyLayer(ps.m_Possessed, from, Layer.Pants);
                        CopyLayer(ps.m_Possessed, from, Layer.Shirt);
                        CopyLayer(ps.m_Possessed, from, Layer.Helm);
                        CopyLayer(ps.m_Possessed, from, Layer.Gloves);
                        CopyLayer(ps.m_Possessed, from, Layer.Ring);
                        CopyLayer(ps.m_Possessed, from, Layer.Neck);
                        CopyLayer(ps.m_Possessed, from, Layer.Hair);
                        CopyLayer(ps.m_Possessed, from, Layer.Waist);
                        CopyLayer(ps.m_Possessed, from, Layer.InnerTorso);
                        CopyLayer(ps.m_Possessed, from, Layer.Bracelet);
                        CopyLayer(ps.m_Possessed, from, Layer.FacialHair);
                        CopyLayer(ps.m_Possessed, from, Layer.MiddleTorso);
                        CopyLayer(ps.m_Possessed, from, Layer.Earrings);
                        CopyLayer(ps.m_Possessed, from, Layer.Arms);
                        CopyLayer(ps.m_Possessed, from, Layer.Cloak);
                        CopyLayer(ps.m_Possessed, from, Layer.OuterTorso);
                        CopyLayer(ps.m_Possessed, from, Layer.OuterLegs);
                        CopyLayer(ps.m_Possessed, from, Layer.LastUserValid);

                        // save and set basics
                        ps.m_Possessor = from;

                        ps.m_Name = from.Name;
                        from.Name = ps.m_Possessed.Name;

                        ps.m_Title = from.Title;
                        from.Title = ps.m_Possessed.Title;

                        ps.m_Hue = from.Hue;
                        from.Hue = ps.m_Possessed.Hue;

                        ps.m_SpeechHue = from.SpeechHue;
                        from.SpeechHue = ps.m_Possessed.SpeechHue;

                        ps.m_BodyValue = from.BodyValue;
                        from.BodyValue = ps.m_Possessed.BodyValue;

                        ps.m_Female = from.Female;
                        from.Female = ps.m_Possessed.Female;

                        ps.m_Karma = from.Karma;
                        from.Karma = ps.m_Possessed.Karma;

                        ps.m_Fame = from.Fame;
                        from.Fame = ps.m_Possessed.Fame;

                        ps.m_Kills = from.Kills;
                        from.Kills = ps.m_Possessed.Kills;

                        // if mounted, dismount.
                        // Just be sure you are riding an ethy or you will abandon your mount
                        IMount ride = from.Mount;
                        if (ride != null)
                        {
                            ride.Rider = null;
                        }

                        // orient and display
                        Point3D m_Location = new Point3D(ps.m_Possessed.Location.X, ps.m_Possessed.Location.Y, ps.m_Possessed.Location.Z);
                        from.Direction = ps.m_Possessed.Direction;
                        from.MoveToWorld(m_Location, ps.m_Possessed.Map);
                        from.Hidden = false;
                        // hide the mobile
                        ps.m_Possessed.Hidden   = true;
                        ps.m_Possessed.CantWalk = true;
                        ps.m_Possessing         = true;
                    }
                }
                else
                {
                    from.SendMessage("You can't possess that!");
                }
            }
Example #38
0
        public static void CheckDrop(BaseCreature bc, Container c)
        {
            if (m_IngredientTable != null)
            {
                foreach (IngredientDropEntry entry in m_IngredientTable)
                {
                    if (entry == null)
                    {
                        continue;
                    }

                    if (entry.Region != null)
                    {
                        string reg = entry.Region;

                        if (reg == "TerMur" && c.Map != Map.TerMur)
                        {
                            continue;
                        }
                        else if (reg == "Abyss" && (c.Map != Map.TerMur || c.X < 235 || c.X > 1155 || c.Y < 40 || c.Y > 1040))
                        {
                            continue;
                        }
                        else if (reg != "TerMur" && reg != "Abyss")
                        {
                            Server.Region r = Server.Region.Find(c.Location, c.Map);

                            if (r == null || !r.IsPartOf(entry.Region))
                            {
                                continue;
                            }
                        }
                    }

                    if (bc.GetType() != entry.CreatureType && !bc.GetType().IsSubclassOf(entry.CreatureType))
                    {
                        continue;
                    }

                    double      toBeat = entry.Chance;
                    List <Item> drops  = new List <Item>();

                    if (bc is BaseVoidCreature)
                    {
                        toBeat *= ((BaseVoidCreature)bc).Stage + 1;
                    }

                    if (entry.DropMultiples)
                    {
                        foreach (Type type in entry.Ingredients)
                        {
                            if (toBeat >= Utility.RandomDouble())
                            {
                                Item drop = Loot.Construct(type);

                                if (drop != null)
                                {
                                    drops.Add(drop);
                                }
                            }
                        }
                    }
                    else if (toBeat >= Utility.RandomDouble())
                    {
                        Item drop = Loot.Construct(entry.Ingredients);

                        if (drop != null)
                        {
                            drops.Add(drop);
                        }
                    }

                    foreach (Item item in drops)
                    {
                        c.DropItem(item);
                    }
                }
            }
        }
        public static void EmptyPackOnExit(Mobile m, bool DeletePasses, bool KeepStartup)
        {
            Container backpack = m.Backpack;

            if (backpack == null)
            {
                return;
            }

            // put whatever you are holding in you backpack
            // (the 'drag' kind of holding)
            Item held = m.Holding;

            if (held != null)
            {
                held.ClearBounce();
                if (m.Backpack != null)
                {
                    m.Backpack.DropItem(held);
                }
            }
            m.Holding = null;

            // put whatever you are holding in your backpack
            // (actually in your hand kind of holding)
            Item weapon = m.Weapon as Item;

            if (weapon != null && weapon.Parent == m && !(weapon is Fists))
            {
                backpack.DropItem(weapon);
            }

            ArrayList stuff = backpack.FindAllItems();

            if (stuff != null && stuff.Count > 0)
            {
                for (int ix = 0; ix < stuff.Count; ix++)
                {
                    Item item = stuff[ix] as Item;
                    // process items as follows
                    //	delete weapons (except stinger) and reagents
                    //	change stinger to regular loot
                    //	delete reagents
                    //	Oprional delete lighthouse passes - (they were handled on entrance to the escape cave)
                    //	delete spellbook
                    // we don't delete EVERYTHING because we may allow some rares to be found here in the future

                    if (item is BaseWeapon && item is AIStinger == false)
                    {
                        item.Delete();
                    }

                    if (item is AIStinger && KeepStartup == false)
                    {
                        item.LootType = LootType.Regular;
                    }

                    if (item is BaseReagent)
                    {
                        item.Delete();
                    }

                    if (item is AILHPass && DeletePasses)
                    {
                        item.Delete();
                    }

                    if (item is Spellbook && KeepStartup == false)
                    {
                        item.Delete();
                    }
                }
            }

            return;
        }
Example #40
0
        private void CheckPreAOSMoves(Mobile attacker, Mobile defender)
        {
            if (attacker.StunReady)
            {
                if (attacker.CanBeginAction(typeof(Fists)))
                {
                    if (attacker.Skills[SkillName.Anatomy].Value >= 80.0 && attacker.Skills[SkillName.Wrestling].Value >= 80.0)
                    {
                        if (attacker.Stam >= 15)
                        {
                            attacker.Stam -= 15;

                            if (CheckMove(attacker, SkillName.Anatomy))
                            {
                                StartMoveDelay(attacker);

                                attacker.StunReady = false;

                                attacker.SendLocalizedMessage(1004013); // You successfully stun your opponent!
                                defender.SendLocalizedMessage(1004014); // You have been stunned!

                                defender.Freeze(TimeSpan.FromSeconds(4.0));
                            }
                            else
                            {
                                attacker.SendLocalizedMessage(1004010); // You failed in your attempt to stun.
                                defender.SendLocalizedMessage(1004011); // Your opponent tried to stun you and failed.
                            }
                        }
                        else
                        {
                            attacker.SendLocalizedMessage(1004009); // You are too fatigued to attempt anything.
                        }
                    }
                    else
                    {
                        attacker.SendLocalizedMessage(1004008); // You are not skilled enough to stun your opponent.
                        attacker.StunReady = false;
                    }
                }
            }
            else if (attacker.DisarmReady)
            {
                if (attacker.CanBeginAction(typeof(Fists)))
                {
                    if (defender.Player || defender.Body.IsHuman)
                    {
                        if (attacker.Skills[SkillName.ArmsLore].Value >= 80.0 && attacker.Skills[SkillName.Wrestling].Value >= 80.0)
                        {
                            if (attacker.Stam >= 15)
                            {
                                Item toDisarm = defender.FindItemOnLayer(Layer.OneHanded);

                                if (toDisarm == null || !toDisarm.Movable)
                                {
                                    toDisarm = defender.FindItemOnLayer(Layer.TwoHanded);
                                }

                                Container pack = defender.Backpack;

                                if (pack == null || toDisarm == null || !toDisarm.Movable)
                                {
                                    attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
                                }
                                else if (CheckMove(attacker, SkillName.ArmsLore))
                                {
                                    StartMoveDelay(attacker);

                                    attacker.Stam       -= 15;
                                    attacker.DisarmReady = false;

                                    attacker.SendLocalizedMessage(1004006); // You successfully disarm your opponent!
                                    defender.SendLocalizedMessage(1004007); // You have been disarmed!

                                    pack.DropItem(toDisarm);
                                }
                                else
                                {
                                    attacker.Stam -= 15;

                                    attacker.SendLocalizedMessage(1004004); // You failed in your attempt to disarm.
                                    defender.SendLocalizedMessage(1004005); // Your opponent tried to disarm you but failed.
                                }
                            }
                            else
                            {
                                attacker.SendLocalizedMessage(1004003); // You are too fatigued to attempt anything.
                            }
                        }
                        else
                        {
                            attacker.SendLocalizedMessage(1004002); // You are not skilled enough to disarm your opponent.
                            attacker.DisarmReady = false;
                        }
                    }
                    else
                    {
                        attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
                    }
                }
            }
        }
Example #41
0
        public static void CheckDrop(BaseCreature bc, Container c)
        {
            if (m_IngredientTable != null)
            {
                for (var index = 0; index < m_IngredientTable.Count; index++)
                {
                    IngredientDropEntry entry = m_IngredientTable[index];

                    if (entry == null)
                    {
                        continue;
                    }

                    if (entry.Region != null)
                    {
                        string reg = entry.Region;

                        if (reg == "TerMur" && c.Map != Map.TerMur)
                        {
                            continue;
                        }

                        if (reg == "Abyss" && (c.Map != Map.TerMur || c.X < 235 || c.X > 1155 || c.Y < 40 || c.Y > 1040))
                        {
                            continue;
                        }

                        if (reg != "TerMur" && reg != "Abyss")
                        {
                            Region r = Server.Region.Find(c.Location, c.Map);

                            if (r == null || !r.IsPartOf(entry.Region))
                            {
                                continue;
                            }
                        }
                    }

                    if (bc.GetType() != entry.CreatureType && !bc.GetType().IsSubclassOf(entry.CreatureType))
                    {
                        continue;
                    }

                    double      toBeat = entry.Chance;
                    List <Item> drops  = new List <Item>();

                    if (bc is BaseVoidCreature creature)
                    {
                        toBeat *= creature.Stage + 1;
                    }

                    if (entry.DropMultiples)
                    {
                        for (var i = 0; i < entry.Ingredients.Length; i++)
                        {
                            Type type = entry.Ingredients[i];

                            if (toBeat >= Utility.RandomDouble())
                            {
                                Item drop = Loot.Construct(type);

                                if (drop != null)
                                {
                                    drops.Add(drop);
                                }
                            }
                        }
                    }
                    else if (toBeat >= Utility.RandomDouble())
                    {
                        Item drop = Loot.Construct(entry.Ingredients);

                        if (drop != null)
                        {
                            drops.Add(drop);
                        }
                    }

                    for (var i = 0; i < drops.Count; i++)
                    {
                        Item item = drops[i];

                        c.DropItem(item);
                    }

                    ColUtility.Free(drops);
                }
            }
        }
Example #42
0
        public override void OnHit(Mobile attacker, Mobile defender, int damage)
        {
            if (!Validate(attacker))
            {
                return;
            }

            ClearCurrentAbility(attacker);

            if (IsImmune(defender))
            {
                attacker.SendLocalizedMessage(1111827); // Your opponent is gripping their weapon too tightly to be disarmed.
                defender.SendLocalizedMessage(1111828); // You will not be caught off guard by another disarm attack for some time.
                return;
            }

            Item toDisarm = defender.FindItemOnLayer(Layer.OneHanded);

            if (toDisarm == null || !toDisarm.Movable)
            {
                toDisarm = defender.FindItemOnLayer(Layer.TwoHanded);
            }

            Container pack = defender.Backpack;

            if (pack == null || (toDisarm != null && !toDisarm.Movable))
            {
                attacker.SendLocalizedMessage(1004001); // You cannot disarm your opponent.
            }
            else if (toDisarm == null || toDisarm is BaseShield)
            {
                attacker.SendLocalizedMessage(1060849); // Your target is already unarmed!
            }
            else if (CheckMana(attacker, true))
            {
                attacker.SendLocalizedMessage(1060092); // You disarm their weapon!
                defender.SendLocalizedMessage(1060093); // Your weapon has been disarmed!

                defender.PlaySound(0x3B9);
                defender.FixedParticles(0x37BE, 232, 25, 9948, EffectLayer.LeftHand);

                pack.DropItem(toDisarm);

                BuffInfo.AddBuff(defender, new BuffInfo(BuffIcon.NoRearm, 1075637, BlockEquipDuration, defender));

                BaseWeapon.BlockEquip(defender, BlockEquipDuration);

                if (defender is BaseCreature && _AutoRearms.Any(t => t == defender.GetType()))
                {
                    Timer.DelayCall(BlockEquipDuration + TimeSpan.FromSeconds(Utility.RandomMinMax(3, 10)), () =>
                    {
                        if (toDisarm != null && !toDisarm.Deleted && toDisarm.IsChildOf(defender.Backpack))
                        {
                            defender.EquipItem(toDisarm);
                        }
                    });
                }

                AddImmunity(defender, attacker.Weapon is Fists ? TimeSpan.FromSeconds(10) : TimeSpan.FromSeconds(15));
            }
        }
Example #43
0
        private void AddItems(Container pack)
        {
            pack.DropItem(new BagOfReagents());
            pack.DropItem(new Spellbook(ulong.MaxValue));

            BaseWeapon weaps = new Halberd();

            weaps.Quality = WeaponQuality.Exceptional;
            pack.DropItem(weaps);

            weaps         = new Katana();
            weaps.Quality = WeaponQuality.Exceptional;
            pack.DropItem(weaps);

            weaps         = new ShortSpear();
            weaps.Quality = WeaponQuality.Exceptional;
            pack.DropItem(weaps);

            weaps         = new WarMace();
            weaps.Quality = WeaponQuality.Exceptional;
            pack.DropItem(weaps);

            pack.DropItem(new GreaterPoisonPotion());
            pack.DropItem(new GreaterPoisonPotion());

            pack.DropItem(new GreaterHealPotion());
            pack.DropItem(new GreaterHealPotion());
            pack.DropItem(new GreaterHealPotion());
            pack.DropItem(new GreaterHealPotion());

            pack.DropItem(new GreaterCurePotion());
            pack.DropItem(new GreaterCurePotion());
            pack.DropItem(new GreaterCurePotion());

            pack.DropItem(new TotalRefreshPotion());
            pack.DropItem(new TotalRefreshPotion());

            pack.DropItem(new GreaterExplosionPotion());
            pack.DropItem(new GreaterExplosionPotion());
            pack.DropItem(new GreaterExplosionPotion());

            pack.DropItem(new Bandage(20));

            for (int i = 0; i < 3; i++)
            {
                TrapableContainer cont = new Pouch();
                cont.TrapType  = TrapType.MagicTrap;
                cont.TrapPower = 1;
                cont.TrapLevel = 0;
                pack.DropItem(cont);
            }
        }