Exemple #1
0
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            switch (m_DeedType)
            {
            case BODType.Smith: bod = new SmallSmithBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;

            case BODType.Tailor: bod = new SmallTailorBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;

            case BODType.Inscription: bod = new SmallInscriptionBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;

            case BODType.Alchemy: bod = new SmallAlchemyBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;

            case BODType.Carpentry: bod = new SmallCarpentryBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;

            case BODType.Fletching: bod = new SmallFletchingBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;

            case BODType.Tinkering: bod = new SmallTinkerBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue, m_GemType); break;

            case BODType.Cooking: bod = new SmallCookingBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue); break;
            }

            return(bod);
        }
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            if (m_DeedType == BODType.Smith)
            {
                bod = new SmallSmithBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            else if (m_DeedType == BODType.Tailor)
            {
                bod = new SmallTailorBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            else if (m_DeedType == BODType.Inscription)
            {
                bod = new SmallInscriptionBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue);
            }
            else if (m_DeedType == BODType.Alchemy)
            {
                bod = new SmallAlchemyBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue);
            }
            else if (m_DeedType == BODType.Carpentry)
            {
                bod = new SmallCarpentryBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue);
            }
            else if (m_DeedType == BODType.Fletching)
            {
                bod = new SmallFletchingBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue);
            }
            else if (m_DeedType == BODType.Cooking)
            {
                bod = new SmallCookingBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Hue);
            }

            return(bod);
        }
Exemple #3
0
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            if (this.m_DeedType == BODType.Smith)
            {
                bod = new SmallSmithBOD(this.m_AmountCur, this.m_AmountMax, this.m_ItemType, this.m_Number, this.m_Graphic, this.m_RequireExceptional, this.m_Material);
            }
            else if (this.m_DeedType == BODType.Tailor)
            {
                bod = new SmallTailorBOD(this.m_AmountCur, this.m_AmountMax, this.m_ItemType, this.m_Number, this.m_Graphic, this.m_RequireExceptional, this.m_Material);
            }
            //--<< Custom BODs Edit>>-------------------------------[Start 1 of 2]
            else if (m_DeedType == BODType.Carpenter)
            {
                bod = new SmallCarpenterBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            else if (m_DeedType == BODType.Fletcher)
            {
                bod = new SmallFletcherBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            //--<< Custom BODs Edit>>-------------------------------[End 1 of 2]

            return(bod);
        }
Exemple #4
0
		public Item Reconstruct()
		{
			SmallBOD bod = null;

			if ( m_DeedType == BODType.Smith )
				bod = new SmallSmithBOD( m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material );
			else if ( m_DeedType == BODType.Tailor )
				bod = new SmallTailorBOD( m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material );

			return bod;
		}
Exemple #5
0
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            if (DeedType == BODType.Smith)
            {
                bod = new SmallSmithBOD(AmountCur, AmountMax, ItemType, Number, Graphic, RequireExceptional, Material);
            }
            else if (DeedType == BODType.Tailor)
            {
                bod = new SmallTailorBOD(AmountCur, AmountMax, ItemType, Number, Graphic, RequireExceptional, Material);
            }

            return(bod);
        }
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            if (this.m_DeedType == BODType.Smith)
            {
                bod = new SmallSmithBOD(this.m_AmountCur, this.m_AmountMax, this.m_ItemType, this.m_Number, this.m_Graphic, this.m_RequireExceptional, this.m_Material);
            }
            else if (this.m_DeedType == BODType.Tailor)
            {
                bod = new SmallTailorBOD(this.m_AmountCur, this.m_AmountMax, this.m_ItemType, this.m_Number, this.m_Graphic, this.m_RequireExceptional, this.m_Material);
            }

            return(bod);
        }
Exemple #7
0
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            if (m_DeedType == BODType.Smith)
            {
                bod = new SmallSmithBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Owner);
            }
            else if (m_DeedType == BODType.Tailor)
            {
                bod = new SmallTailorBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material, m_Owner);
            }
            // ***
            else if (m_DeedType == BODType.Hunter)
            {
                bod = new SmallHuntBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, (int)m_Material, m_Owner);
            }
            // ***

            return(bod);
        }
        public Item Reconstruct()
        {
            SmallBOD bod = null;

            if (m_DeedType == BODType.Smith)
            {
                bod = new SmallSmithBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            else if (m_DeedType == BODType.Tailor)
            {
                bod = new SmallTailorBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            else if (m_DeedType == BODType.Carpenter)
            {
                bod = new SmallCarpenterBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }
            else if (m_DeedType == BODType.Fletcher)
            {
                bod = new SmallFletcherBOD(m_AmountCur, m_AmountMax, m_ItemType, m_Number, m_Graphic, m_RequireExceptional, m_Material);
            }

            return(bod);
        }
Exemple #9
0
        public static Item CreateBulkOrder(Mobile m, BODType type, bool fromContextMenu)
        {
            PlayerMobile pm = m as PlayerMobile;

            if (pm == null)
            {
                return(null);
            }

            if (pm.AccessLevel > AccessLevel.Player || fromContextMenu || 0.2 > Utility.RandomDouble())
            {
                SkillName sk         = GetSkillForBOD(type);
                double    theirSkill = pm.Skills[sk].Base;
                bool      doLarge    = theirSkill >= 70.1 && ((theirSkill - 40.0) / 300.0) > Utility.RandomDouble();

                switch (type)
                {
                case BODType.Smith:
                    if (doLarge)
                    {
                        return(new LargeSmithBOD());
                    }
                    else
                    {
                        return(SmallSmithBOD.CreateRandomFor(pm));
                    }

                case BODType.Tailor: if (doLarge)
                    {
                        return(new LargeTailorBOD());
                    }
                    else
                    {
                        return(SmallTailorBOD.CreateRandomFor(pm));
                    }

                case BODType.Alchemy:
                    if (doLarge)
                    {
                        return(new LargeAlchemyBOD());
                    }
                    else
                    {
                        return(SmallAlchemyBOD.CreateRandomFor(pm));
                    }

                case BODType.Inscription:
                    if (doLarge)
                    {
                        return(new LargeInscriptionBOD());
                    }
                    else
                    {
                        return(SmallInscriptionBOD.CreateRandomFor(pm));
                    }

                case BODType.Tinkering:
                    if (doLarge)
                    {
                        return(new LargeTinkerBOD());
                    }
                    else
                    {
                        return(SmallTinkerBOD.CreateRandomFor(pm));
                    }

                case BODType.Cooking:
                    if (doLarge)
                    {
                        return(new LargeCookingBOD());
                    }
                    else
                    {
                        return(SmallCookingBOD.CreateRandomFor(pm));
                    }

                case BODType.Fletching:
                    if (doLarge)
                    {
                        return(new LargeFletchingBOD());
                    }
                    else
                    {
                        return(SmallFletchingBOD.CreateRandomFor(pm));
                    }

                case BODType.Carpentry:
                    if (doLarge)
                    {
                        return(new LargeCarpentryBOD());
                    }
                    else
                    {
                        return(SmallCarpentryBOD.CreateRandomFor(pm));
                    }
                }
            }

            return(null);
        }
        public override void DoTransmute(Mobile from, Recipe r)
        {
            if(r == null || from == null) return;

            Recipes rid = (Recipes) r.RecipeID;
            switch(rid)
            {
                case Recipes.PowerScrollSkillChange:
                {
                    // get the target value from one of the powerscrolls
                    Item [] slist = FindItemsByType(typeof(PowerScroll), true);
                    
                    double value = 0;
                    // make sure they are all of the same value
                    foreach(Item s in slist)
                    {
                        if(value == 0)
                        {
                            value = ((PowerScroll)s).Value;
                        } else
                        {
                            if(value != ((PowerScroll)s).Value)
                            {
                                from.SendMessage("All powerscrolls must be of the same level");
                                return;
                            }
                        }
                    }

                    PowerScroll newps = PowerScroll.CreateRandom( (int)(value - 100), (int)(value - 100) );

                    // consume ingredients
                    ConsumeAll();
                    
                    // add the new powerscroll
                    DropItem(newps);

                    break;
                }
                case Recipes.SmallBODChange:
                {
                    // get the target value from one of the powerscrolls
                    Item [] slist = FindItemsByType(typeof(SmallBOD), true);
                    
                    Type t = null;
                    // make sure they are all of the same type
                    foreach(Item s in slist)
                    {
                        if(t == null)
                        {
                            t = ((SmallBOD)s).GetType();
                        } else
                        {
                            if(t != ((SmallBOD)s).GetType())
                            {
                                from.SendMessage("All BODs must be of the same type");
                                return;
                            }
                        }
                    }
                    
                    SmallBOD newbod = null;

                    if(t == typeof(SmallTailorBOD))
                    {
                    	newbod = new SmallTailorBOD();
                    } else
                    if(t == typeof(SmallSmithBOD))
                    {
                    	newbod = new SmallSmithBOD();
                    } else
                    {
                    	from.SendMessage("Cannot transmute those BODs");
                    	return;
                    }

					if(newbod == null) return;

                    // consume ingredients
                    ConsumeAll();
                    
                    // add the new powerscroll
                    DropItem(newbod);

                    break;
                }
                case Recipes.LargeBODChange:
                {
                    // get the target value from one of the powerscrolls
                    Item [] slist = FindItemsByType(typeof(LargeBOD), true);
                    
                    Type t = null;
                    // make sure they are all of the same type
                    foreach(Item s in slist)
                    {
                        if(t == null)
                        {
                            t = ((LargeBOD)s).GetType();
                        } else
                        {
                            if(t != ((LargeBOD)s).GetType())
                            {
                                from.SendMessage("All BODs must be of the same type");
                                return;
                            }
                        }
                    }
                    
                    LargeBOD newbod = null;

                    if(t == typeof(LargeTailorBOD))
                    {
                    	newbod = new LargeTailorBOD();
                    } else
                    if(t == typeof(LargeSmithBOD))
                    {
                    	newbod = new LargeSmithBOD();
                    } else
                    {
                    	from.SendMessage("Cannot transmute those BODs");
                    	return;
                    }

					if(newbod == null) return;

                    // consume ingredients
                    ConsumeAll();
                    
                    // add the new powerscroll
                    DropItem(newbod);

                    break;
                }
                case Recipes.UpgradeAncientAugment:
                {
                    // check what type of augment is being upgraded
                    BaseSocketAugmentation augment = null;
                    if(Items.Count > 0)
                    {
                        augment = Items[0] as BaseSocketAugmentation;
                    }

                    if(augment == null) return;

                    // make sure they are all the same
                    foreach(Item i in Items)
                    {
                        if(augment.GetType() != i.GetType()) return;
                    }

                    // take the ingredients
                    ConsumeAll();
                    // and add the result
                    if(augment is AncientDiamond)
                    {
                        DropItem(new LegendaryDiamond() );
                    } else
                    if(augment is AncientSapphire)
                    {
                        DropItem(new LegendarySapphire() );
                    } else
                    if(augment is AncientSkull)
                    {
                        DropItem(new LegendarySkull() );
                    } else
                    if(augment is AncientTourmaline)
                    {
                        DropItem(new LegendaryTourmaline() );
                    } else
                    if(augment is AncientWood)
                    {
                        DropItem(new LegendaryWood() );
                    } else
                    if(augment is AncientRuby)
                    {
                        DropItem(new LegendaryRuby() );
                    } else
                    if(augment is AncientEmerald)
                    {
                        DropItem(new LegendaryEmerald() );
                    }
					else
						if(augment is AncientAmethyst)
					{
						DropItem(new LegendaryAmethyst() );
					}

                    break;
                }
                case Recipes.UpgradeLegendaryAugment:
                {
                    // check what type of augment is being upgraded
                    BaseSocketAugmentation augment = null;
                    if(Items.Count > 0)
                    {
                        augment = Items[0] as BaseSocketAugmentation;
                    }

                    if(augment == null) return;

                    // make sure they are all the same
                    foreach(Item i in Items)
                    {
                        if(augment.GetType() != i.GetType()) return;
                    }

                    // take the ingredients
                    ConsumeAll();

                    // and add the result
                    if(augment is LegendaryDiamond)
                    {
                        DropItem(new MythicDiamond() );
                    } else
                    if(augment is LegendarySapphire)
                    {
                        DropItem(new MythicSapphire() );
                    } else
                    if(augment is LegendarySkull)
                    {
                        DropItem(new MythicSkull() );
                    } else
                    if(augment is LegendaryTourmaline)
                    {
                        DropItem(new MythicTourmaline() );
                    } else
                    if(augment is LegendaryWood)
                    {
                        DropItem(new MythicWood() );
                    } else
                    if(augment is LegendaryRuby)
                    {
                        DropItem(new MythicRuby() );
                    } else
                    if(augment is LegendaryEmerald)
                    {
                        DropItem(new MythicEmerald() );
                    }
					else
						if(augment is LegendaryAmethyst)
					{
						DropItem(new MythicAmethyst() );
					}

                    break;
                }
                case Recipes.UpgradeCrystalAugment:
                {
                    // check what type of augment is being upgraded
                    BaseSocketAugmentation augment = null;
                    if(Items.Count > 0)
                    {
                        augment = Items[0] as BaseSocketAugmentation;
                    }
                    
                    if(augment == null) return;
                    
                    // make sure they are all the same
                    foreach(Item i in Items)
                    {
                        if(augment.GetType() != i.GetType()) return;
                    }

                    // take the ingredients
                    ConsumeAll();

                    // and add the result
                    if(augment is RhoCrystal)
                    {
                        DropItem(new RadiantRhoCrystal() );
                    } else
                    if(augment is RysCrystal)
                    {
                        DropItem(new RadiantRysCrystal() );
                    } else
                    if(augment is WyrCrystal)
                    {
                        DropItem(new RadiantWyrCrystal() );
                    } else
                    if(augment is FreCrystal)
                    {
                        DropItem(new RadiantFreCrystal() );
                    } else
                    if(augment is TorCrystal)
                    {
                        DropItem(new RadiantTorCrystal() );
                    } else
                    if(augment is VelCrystal)
                    {
                        DropItem(new RadiantVelCrystal() );
                    } else
                    if(augment is XenCrystal)
                    {
                        DropItem(new RadiantXenCrystal() );
                    } else
                    if(augment is PolCrystal)
                    {
                        DropItem(new RadiantPolCrystal() );
                    } else
                    if(augment is WolCrystal)
                    {
                        DropItem(new RadiantWolCrystal() );
                    } else
                    if(augment is BalCrystal)
                    {
                        DropItem(new RadiantBalCrystal() );
                    } else
                    if(augment is TalCrystal)
                    {
                        DropItem(new RadiantTalCrystal() );
                    } else
                    if(augment is JalCrystal)
                    {
                        DropItem(new RadiantJalCrystal() );
                    } else
                    if(augment is RalCrystal)
                    {
                        DropItem(new RadiantRalCrystal() );
                    } else
                    if(augment is KalCrystal)
                    {
                        DropItem(new RadiantKalCrystal() );
                    }

                    break;

                }
                case Recipes.RecoverAugmentation:
                {
                    // does item have any sockets on it?
                    Item b = FindItemByType(typeof(BaseArmor), true);
                    if(b == null)
                        b = FindItemByType(typeof(BaseWeapon), true);
                    if(b == null)
                        b = FindItemByType(typeof(BaseJewel), true);

                    XmlSockets a = XmlAttach.FindAttachment(b, typeof(XmlSockets)) as XmlSockets;
                    if(a == null)
                    {
                        // if so then forget it
                        from.SendMessage("This item is not socketed.");
                        return;
                    }


                    if(a.NSockets == 0)
                    {
                        from.SendMessage("This item is has no sockets.");
                        return;
                    }

                    BaseSocketAugmentation augment = a.RecoverRandomAugmentation(from, b);

                    if(augment != null)
                    {
                        // consume the crystal
                        ConsumeTotal(typeof(AncientRuby), 1, true);

                        // put the recovered augment in the container
                        DropItem(augment);

                        from.SendMessage("Recovered a {0} augmentation.", augment.Name);
                        
                        // update the sockets gump
                        a.OnIdentify(from);

                    } else
                    {
                        from.SendMessage("Failed to recover augmentation.");
                    }


                    break;
                }
                case Recipes.HammerOfRecovery:
                {
                    // consume ingredients
                    ConsumeAll();
                    
                    // add the hammer
                    DropItem(new HammerOfRecovery(1));

                    break;
                }
                
                case Recipes.ExceptionalSocketHammer:
                {
                    // consume ingredients
                    ConsumeAll();
                    
                    // add the hammer
                    DropItem(new ExceptionalSocketHammer(1));

                    break;
                }
                
                case Recipes.SocketWeapon:
                {
                    // does the weapon already have any sockets on it?
                    Item b = FindItemByType(typeof(BaseWeapon), true);
                    XmlAttachment a = XmlAttach.FindAttachment(b, typeof(XmlSockets));
                    if(a != null)
                    {
                        // if so then forget it
                        from.SendMessage("Weapon already socketed.");
                        return;
                    }
                    // otherwise add the socket
                    XmlAttach.AttachTo(b, new XmlSockets(1));
                    // consume the crystal
                    ConsumeTotal(typeof(RadiantRhoCrystal), 1, true);
                    break;
                }
                case Recipes.SocketArmor:
                {
                    // does the armor already have any sockets on it?
                    Item b = FindItemByType(typeof(BaseArmor), true);
                    XmlAttachment a = XmlAttach.FindAttachment(b, typeof(XmlSockets));
                    if(a != null)
                    {
                        // if so then forget it
                        from.SendMessage("Armor already socketed.");
                        return;
                    }
                    // otherwise add the socket
                    XmlAttach.AttachTo(b, new XmlSockets(1));
                    // consume the crystal
                    ConsumeTotal(typeof(RadiantRhoCrystal), 1, true);
                    break;
                }
// Uncomment the follow recipes if you have XmlMobFactions installed and you would like to allow faction gain through these recipes

#if(XMLMOBFACTIONS)
                case Recipes.UndeadFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();

                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Undead", value));
                    break;
                }
                case Recipes.AbyssFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();

                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Abyss", value));
                    break;
                }
                case Recipes.HumanoidFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();

                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Humanoid", value));
                    break;
                }
                case Recipes.ReptilianFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();
                    
                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Reptilian", value));
                    break;
                }
                case Recipes.ArachnidFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();

                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Arachnid", value));
                    break;
                }
                case Recipes.ElementalFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();
                    
                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Elemental", value));
                    break;
                }
                case Recipes.UnderworldFaction:
                {
                    // how much gold is being offered
                    Item b = FindItemByType(typeof(Gold), true);

                    int value = 0;
                    if(b != null)
                    {
                        value = b.Amount/10;
                    }

                    // take the ingredients
                    ConsumeAll();
                    
                    // add the faction
                    XmlAttach.AttachTo(from, new XmlAddFaction("Underworld", value));
                    break;
                }

// end of commented-out XmlMobFactions recipes
#endif
            }

            // give effects for successful transmutation
            from.PlaySound(503);
            
            base.DoTransmute(from, r);
        }
Exemple #11
0
        private static void DocumentBulkOrders()
        {
            using ( StreamWriter html = GetWriter( "docs/bods/", "bod_smith_rewards.html" ) )
            {
                html.WriteLine( "<html>" );
                html.WriteLine( "   <head>" );
                html.WriteLine( "      <title>RunUO Documentation - Bulk Orders - Smith Rewards</title>" );
                html.WriteLine( "      <link rel=\"stylesheet\" type=\"text/css\" href=\"../styles.css\" />" );
                html.WriteLine( "   </head>" );
                html.WriteLine( "   <body>" );

                SmallBOD sbod = new SmallSmithBOD();

                sbod.Type = typeof( Katana );
                sbod.Material = BulkMaterialType.None;
                sbod.AmountMax = 10;

                WriteSmithBODHeader( html, "(Small) Weapons" );
                sbod.RequireExceptional = false;
                DocumentSmithBOD( html, sbod.ComputeRewards( true ), "10, 15, 20: Normal", sbod.Material );
                sbod.RequireExceptional = true;
                DocumentSmithBOD( html, sbod.ComputeRewards( true ), "10, 15, 20: Exceptional", sbod.Material );
                WriteSmithBODFooter( html );

                html.WriteLine( "      <br><br>" );
                html.WriteLine( "      <br><br>" );

                sbod.Type = typeof( PlateArms );

                WriteSmithBODHeader( html, "(Small) Armor: Normal" );

                sbod.RequireExceptional = false;
                for ( BulkMaterialType mat = BulkMaterialType.None; mat <= BulkMaterialType.Valorite; ++mat )
                {
                    sbod.Material = mat;
                    sbod.AmountMax = 10;
                    DocumentSmithBOD( html, sbod.ComputeRewards( true ), "10, 15, 20", sbod.Material );
                }

                WriteSmithBODFooter( html );

                html.WriteLine( "      <br><br>" );

                WriteSmithBODHeader( html, "(Small) Armor: Exceptional" );

                sbod.RequireExceptional = true;
                for ( BulkMaterialType mat = BulkMaterialType.None; mat <= BulkMaterialType.Valorite; ++mat )
                {
                    sbod.Material = mat;

                    for ( int amt = 15; amt <= 20; amt += 5 )
                    {
                        sbod.AmountMax = amt;
                        DocumentSmithBOD( html, sbod.ComputeRewards( true ), amt == 20 ? "20" : "10, 15", sbod.Material );
                    }
                }

                WriteSmithBODFooter( html );

                html.WriteLine( "      <br><br>" );
                html.WriteLine( "      <br><br>" );

                sbod.Delete();

                WriteSmithLBOD( html, "Ringmail", LargeBulkEntry.LargeRing );
                WriteSmithLBOD( html, "Chainmail", LargeBulkEntry.LargeChain );
                WriteSmithLBOD( html, "Platemail", LargeBulkEntry.LargePlate );

                html.WriteLine( "   </body>" );
                html.WriteLine( "</html>" );
            }

            using ( StreamWriter html = GetWriter( "docs/bods/", "bod_tailor_rewards.html" ) )
            {
                html.WriteLine( "<html>" );
                html.WriteLine( "   <head>" );
                html.WriteLine( "      <title>RunUO Documentation - Bulk Orders - Tailor Rewards</title>" );
                html.WriteLine( "      <link rel=\"stylesheet\" type=\"text/css\" href=\"../styles.css\" />" );
                html.WriteLine( "   </head>" );
                html.WriteLine( "   <body>" );

                SmallBOD sbod = new SmallTailorBOD();

                WriteTailorBODHeader( html, "Small Bulk Order" );

                html.WriteLine( "         <tr>" );
                html.WriteLine( "            <td width=\"850\" colspan=\"21\" class=\"entry\"><b>Regular: 10, 15</b></td>" );
                html.WriteLine( "         </tr>" );

                sbod.AmountMax = 10;
                sbod.RequireExceptional = false;

                sbod.Type = typeof( SkullCap );
                sbod.Material = BulkMaterialType.None;
                DocumentTailorBOD( html, sbod.ComputeRewards( true ), "10, 15", sbod.Material, sbod.Type );

                sbod.Type = typeof( LeatherCap );
                for ( BulkMaterialType mat = BulkMaterialType.None; mat <= BulkMaterialType.Barbed; ++mat )
                {
                    if ( mat >= BulkMaterialType.DullCopper && mat <= BulkMaterialType.Valorite )
                        continue;

                    sbod.Material = mat;
                    DocumentTailorBOD( html, sbod.ComputeRewards( true ), "10, 15", sbod.Material, sbod.Type );
                }

                html.WriteLine( "         <tr>" );
                html.WriteLine( "            <td width=\"850\" colspan=\"21\" class=\"entry\"><b>Regular: 20</b></td>" );
                html.WriteLine( "         </tr>" );

                sbod.AmountMax = 20;
                sbod.RequireExceptional = false;

                sbod.Type = typeof( SkullCap );
                sbod.Material = BulkMaterialType.None;
                DocumentTailorBOD( html, sbod.ComputeRewards( true ), "20", sbod.Material, sbod.Type );

                sbod.Type = typeof( LeatherCap );
                for ( BulkMaterialType mat = BulkMaterialType.None; mat <= BulkMaterialType.Barbed; ++mat )
                {
                    if ( mat >= BulkMaterialType.DullCopper && mat <= BulkMaterialType.Valorite )
                        continue;

                    sbod.Material = mat;
                    DocumentTailorBOD( html, sbod.ComputeRewards( true ), "20", sbod.Material, sbod.Type );
                }

                html.WriteLine( "         <tr>" );
                html.WriteLine( "            <td width=\"850\" colspan=\"21\" class=\"entry\"><b>Exceptional: 10, 15</b></td>" );
                html.WriteLine( "         </tr>" );

                sbod.AmountMax = 10;
                sbod.RequireExceptional = true;

                sbod.Type = typeof( SkullCap );
                sbod.Material = BulkMaterialType.None;
                DocumentTailorBOD( html, sbod.ComputeRewards( true ), "10, 15", sbod.Material, sbod.Type );

                sbod.Type = typeof( LeatherCap );
                for ( BulkMaterialType mat = BulkMaterialType.None; mat <= BulkMaterialType.Barbed; ++mat )
                {
                    if ( mat >= BulkMaterialType.DullCopper && mat <= BulkMaterialType.Valorite )
                        continue;

                    sbod.Material = mat;
                    DocumentTailorBOD( html, sbod.ComputeRewards( true ), "10, 15", sbod.Material, sbod.Type );
                }

                html.WriteLine( "         <tr>" );
                html.WriteLine( "            <td width=\"850\" colspan=\"21\" class=\"entry\"><b>Exceptional: 20</b></td>" );
                html.WriteLine( "         </tr>" );

                sbod.AmountMax = 20;
                sbod.RequireExceptional = true;

                sbod.Type = typeof( SkullCap );
                sbod.Material = BulkMaterialType.None;
                DocumentTailorBOD( html, sbod.ComputeRewards( true ), "20", sbod.Material, sbod.Type );

                sbod.Type = typeof( LeatherCap );
                for ( BulkMaterialType mat = BulkMaterialType.None; mat <= BulkMaterialType.Barbed; ++mat )
                {
                    if ( mat >= BulkMaterialType.DullCopper && mat <= BulkMaterialType.Valorite )
                        continue;

                    sbod.Material = mat;
                    DocumentTailorBOD( html, sbod.ComputeRewards( true ), "20", sbod.Material, sbod.Type );
                }

                WriteTailorBODFooter( html );

                html.WriteLine( "      <br><br>" );
                html.WriteLine( "      <br><br>" );

                sbod.Delete();

                WriteTailorLBOD( html, "Large Bulk Order: 4-part", LargeBulkEntry.Gypsy, true, true );
                WriteTailorLBOD( html, "Large Bulk Order: 5-part", LargeBulkEntry.TownCrier, true, true );
                WriteTailorLBOD( html, "Large Bulk Order: 6-part", LargeBulkEntry.MaleLeatherSet, false, true );

                html.WriteLine( "   </body>" );
                html.WriteLine( "</html>" );
            }
        }