Exemplo n.º 1
0
        public Item Construct(Mobile from, int luckChance, bool spawning)
        {
            if (m_AtSpawnTime != spawning)
            {
                return(null);
            }

            int totalChance = 0;

            for (int i = 0; i < m_Items.Length; ++i)
            {
                totalChance += m_Items[i].Chance;
            }

            int rnd = Utility.Random(totalChance);

            for (int i = 0; i < m_Items.Length; ++i)
            {
                LootPackItem item = m_Items[i];

                if (rnd < item.Chance)
                {
                    return(Mutate(from, luckChance, item.Construct(IsInTokuno(from), IsMondain(from), IsStygian(from))));
                }

                rnd -= item.Chance;
            }

            return(null);
        }
Exemplo n.º 2
0
        public Item Construct(Mobile from, bool spawning)
        {
            if (m_AtSpawnTime != spawning)
            {
                return(null);
            }

            int totalChance = 0;

            for (int i = 0; i < m_Items.Length; ++i)
            {
                totalChance += m_Items[i].Chance;
            }

            int rnd = Utility.Random(totalChance);

            for (int i = 0; i < m_Items.Length; ++i)
            {
                LootPackItem item = m_Items[i];

                if (rnd < item.Chance)
                {
                    return(Mutate(from, item.Construct(false, false)));
                }

                rnd -= item.Chance;
            }

            return(null);
        }
Exemplo n.º 3
0
        public Item Construct(Mobile from, int luckChance, bool spawning)
        {
            if (m_AtSpawnTime != spawning)
            {
                return(null);
            }

            int totalChance = 0;

            for (int i = 0; i < m_Items.Length; ++i)
            {
                totalChance += m_Items[i].Chance;
            }

            var inTokuno  = Core.SE && IsInTokuno(from);
            var isMondain = Core.ML && (IsMondain(from) || (from.LastKiller != null ? from.LastKiller.Race : null) == Race.Elf);
            var isStygian = Core.SA && (IsStygian(from) || (from.LastKiller != null ? from.LastKiller.Race : null) == Race.Gargoyle);
            int rnd       = Utility.Random(totalChance);

            for (int i = 0; i < m_Items.Length; ++i)
            {
                LootPackItem item = m_Items[i];
                if (rnd < item.Chance)
                {
                    return(Mutate(from, luckChance, item.Construct(inTokuno, isMondain, isStygian)));
                }

                rnd -= item.Chance;
            }

            return(null);
        }
Exemplo n.º 4
0
        public static LootPack RandomLootItem(Type[] types, double chance, int amount, bool onSpawn, bool onSteal)
        {
            var items = new LootPackItem[types.Length];

            for (int i = 0; i < items.Length; i++)
            {
                items[i] = new LootPackItem(types[i], 1);
            }

            return(new LootPack(new[] { new LootPackEntry(onSpawn, onSteal, items, chance, amount) }));
        }
Exemplo n.º 5
0
        public Item Construct()
        {
            int rnd = Utility.Random(m_TotalChance);

            for (int i = 0; i < m_Items.Length; ++i)
            {
                LootPackItem item = m_Items[i];

                if (rnd < item.Chance)
                {
                    return(Mutate(item.Construct()));
                }

                rnd -= item.Chance;
            }

            return(null);
        }
Exemplo n.º 6
0
        public Item Construct(IEntity from, int luckChance, LootStage stage, bool hasBeenStolenFrom)
        {
            int totalChance = 0;

            for (int i = 0; i < Items.Length; ++i)
            {
                totalChance += Items[i].Chance;
            }

            int rnd = Utility.Random(totalChance);

            for (int i = 0; i < Items.Length; ++i)
            {
                LootPackItem item = Items[i];

                if (rnd < item.Chance)
                {
                    Item loot = null;

                    if (item.ConstructCallback != null)
                    {
                        loot = item.ConstructCallback(from);
                    }
                    else
                    {
                        loot = item.Construct(IsInTokuno(from), IsMondain(from), IsStygian(from));
                    }

                    if (loot != null)
                    {
                        return(Mutate(from, luckChance, loot));
                    }
                }

                rnd -= item.Chance;
            }

            return(null);
        }
Exemplo n.º 7
0
        public Item Construct(Mobile from, int luckChance, bool spawning)
        {
            if (m_AtSpawnTime != spawning)
                return null;

            int totalChance = 0;

            for (int i = 0; i < m_Items.Length; ++i)
                totalChance += m_Items[i].Chance;

            int rnd = Utility.Random(totalChance);

            for (int i = 0; i < m_Items.Length; ++i)
            {
                LootPackItem item = m_Items[i];

                if (rnd < item.Chance)
                    return Mutate(from, luckChance, item.Construct());

                rnd -= item.Chance;
            }

            return null;
        }
Exemplo n.º 8
0
		public LootPackEntry(
			bool atSpawnTime,
			LootPackItem[] items,
			double chance,
			LootPackDice quantity,
			int maxProps,
			int minIntensity,
			int maxIntensity)
		{
			m_AtSpawnTime = atSpawnTime;
			m_Items = items;
			Chance = (int)(100 * chance);
			m_Quantity = quantity;
			m_MaxProps = maxProps;
			m_MinIntensity = minIntensity;
			m_MaxIntensity = maxIntensity;
		}
Exemplo n.º 9
0
		public LootPackEntry(
			bool atSpawnTime, LootPackItem[] items, double chance, int quantity, int maxProps, int minIntensity, int maxIntensity)
			: this(atSpawnTime, items, chance, new LootPackDice(0, 0, quantity), maxProps, minIntensity, maxIntensity)
		{ }
Exemplo n.º 10
0
		public LootPackEntry(bool atSpawnTime, LootPackItem[] items, double chance, int quantity)
			: this(atSpawnTime, items, chance, new LootPackDice(0, 0, quantity), 0, 0, 0)
		{ }
Exemplo n.º 11
0
        public void Generate(Mobile m, Container cont, bool spawning, int luck)
        {
            int index = 0;

            foreach (LootPackEntry entry in m_Entries)
            {
                if (!entry.AtSpawnTime && spawning)
                {
                    index++;
                    continue;
                }

                int itemIndex = Utility.Random(entry.Types.Count);

                bool drop = false;
                if (entry.DropChance >= 100)
                {
                    drop = true;
                }
                else
                {
                    if (entry.DropChance >= Utility.Random(100))
                    {
                        //Console.WriteLine("Create: DropChance >= Creation Chance... ");
                        drop = true;
                    }
                }

                if (!drop)
                {
                    index++;
                    continue;
                }

                //Console.WriteLine("Create: Drop Test Passed");

                /*
                 * Item check = (Item)Activator.CreateInstance(entry.Types[itemIndex]);
                 *
                 * int loop = 1;
                 * if (!check.Stackable)
                 *  loop = entry.DropAmount;
                 */

                for (int a = 0; a < ((entry.Types[itemIndex] == typeof(Gold)) ? 1 : entry.DropAmount); a++)
                {
                    Item looted = null;
                    if (entry.Types[itemIndex] == typeof(BasePotion))
                    {
                        int t = Utility.Random(LootPack.LowPotions.Count);
                        Server.LootPackItem lpi = new Server.LootPackItem(Custom.LootPack.LowPotions[t], 1);
                        looted = lpi.Construct(true, true, true);
                    }
                    else if (entry.Types[itemIndex] == typeof(TreasureMap))
                    {
                        looted = new TreasureMap(Utility.Random(5), Map.Felucca);
                        ((TreasureMap)looted).Decoder = m;
                    }
                    else if (entry.Types[itemIndex] == typeof(BaseRunicTool))
                    {
                        switch (Utility.Random(2))
                        {
                        case 0: looted = new RunicSewingKit(GetRandomLeather()); break;

                        case 1: looted = new RunicHammer(GetRandomMetal()); break;

                        // case 2: looted = new RunicSaw(GetRandomWood()); break;
                        // case 3: looted = new RunicFletcherTools(GetRandomWood()); break;
                        case 2: looted = new RunicSewingKit(GetRandomLeather()); break;    //J.I.C
                        }
                    }
                    else
                    {
                        Server.LootPackItem lpi = new Server.LootPackItem(entry.Types[itemIndex], 1);
                        looted = lpi.Construct(true, true, true);
                    }

                    if (looted == null)
                    {
                        index++;
                        continue;
                    }

                    //Console.WriteLine("Create: Construct Test Passed");
                    //Console.WriteLine("Mutate: # of Possible Attributes = " + entry.AttributeAmount);

                    int chance = 0;
                    for (int b = 0; b < entry.AttributeAmount; b++)
                    {
                        chance = Utility.Random(100);
                        //Console.WriteLine("Mutate: Attach Chance " + chance);
                        int propCount = ItemProps.BonusCount(looted);
                        if (propCount < entry.AttributeAmount && entry.AttributeChance >= chance)
                        {
                            //Console.WriteLine("Mutate: Prop Chance >= Attach Chance");
                            looted = Mutate(m, luck, looted, index, itemIndex);
                        }
                    }

                    if (looted == null)
                    {
                        index++;
                        continue;
                    }

                    // if (looted is BaseRanged/*.GetType().IsSubclassOf(typeof(BaseRanged))*/ && 1 >= Utility.Random(200))

                    /* {
                     *   ((BaseRanged)looted).EnergyBow = true;
                     *   ((BaseRanged)looted).EnergyCost = Utility.RandomMinMax(3, 10);
                     * }*/

                    //if (looted.GetType() == typeof(ScrollofCombatSecrets) || 1 >= Utility.Random(1000))
                    //looted.LootType = LootType.Blessed;

                    if (looted.Stackable)
                    {
                        looted.Amount = entry.DropAmount;
                    }

                    //Skill Bonus Bug Fix
                    Custom.ItemProps.FixSkillBonuses(looted);

                    if (!cont.TryDropItem(m, looted, false))
                    {
                        cont.DropItem(looted);
                    }

                    if (entry.Types.Count > 1)
                    {
                        itemIndex = Utility.Random(entry.Types.Count);
                    }

                    if (looted.Stackable)
                    {
                        break;
                    }
                }

                index++;
            }
        }
Exemplo n.º 12
0
        public LootPackEntry( LootPackItem[] items, double chance, RandMinMax quantity, int minIntensity, int maxIntensity )
        {
            m_Items = items;
            m_Quantity = quantity;
            m_Chance = (int)(100 * chance);
            m_MinIntensity = minIntensity;
            m_MaxIntensity = maxIntensity;

            m_TotalChance = 0;
            for ( int i = 0; i < m_Items.Length; ++i )
                m_TotalChance += m_Items[i].Chance;
        }
Exemplo n.º 13
0
 public LootPackEntry( LootPackItem[] items, double chance, int quantity, int minIntensity, int maxIntensity )
     : this(items, chance, new RandMinMax( quantity ), minIntensity, maxIntensity)
 {
 }
Exemplo n.º 14
0
 public LootPackEntry( LootPackItem[] items, double chance, RandMinMax quantity )
     : this(items, chance, quantity, 0, 0)
 {
 }
Exemplo n.º 15
0
 public LootPackEntry( LootPackItem[] items, double chance, int quantity )
     : this(items, chance, new RandMinMax( quantity ), 0, 0)
 {
 }