828 lines
26 KiB
C#
828 lines
26 KiB
C#
using System;
|
|
using Server.Gumps;
|
|
using Server.Multis;
|
|
using Server.Targeting;
|
|
using Server.Mobiles;
|
|
using Server.Network;
|
|
using Server.Engines.VeteranRewards;
|
|
|
|
namespace Server.Items
|
|
{
|
|
interface IEngravable
|
|
{
|
|
string EngravedText { get; set; }
|
|
}
|
|
|
|
public class BaseEngravingTool : Item, IUsesRemaining, IRewardItem
|
|
{
|
|
private int m_UsesRemaining;
|
|
private bool m_IsRewardItem;
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public int UsesRemaining
|
|
{
|
|
get { return m_UsesRemaining; }
|
|
set
|
|
{
|
|
m_UsesRemaining = value;
|
|
InvalidateProperties();
|
|
}
|
|
}
|
|
|
|
public virtual bool ShowUsesRemaining
|
|
{
|
|
get { return true; }
|
|
set { }
|
|
}
|
|
|
|
[CommandProperty(AccessLevel.GameMaster)]
|
|
public bool IsRewardItem
|
|
{
|
|
get
|
|
{
|
|
return m_IsRewardItem;
|
|
}
|
|
set
|
|
{
|
|
m_IsRewardItem = value;
|
|
InvalidateProperties();
|
|
}
|
|
}
|
|
|
|
[Constructable]
|
|
public BaseEngravingTool(int itemID)
|
|
: this(itemID, 1)
|
|
{
|
|
}
|
|
|
|
[Constructable]
|
|
public BaseEngravingTool(int itemID, int uses)
|
|
: base(itemID)
|
|
{
|
|
Weight = 1.0;
|
|
Hue = 0x48D;
|
|
|
|
LootType = LootType.Blessed;
|
|
|
|
m_UsesRemaining = uses;
|
|
}
|
|
|
|
public BaseEngravingTool(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public virtual bool DeletedItem { get { return true; } }
|
|
public virtual int LowSkillMessage { get { return 0; } }
|
|
public virtual int VeteranRewardCliloc { get { return 0; } }
|
|
|
|
public virtual Type[] Engraves { get { return null; } }
|
|
public virtual int GumpTitle { get { return 1072359; } } // <CENTER>Engraving Tool</CENTER>
|
|
|
|
public virtual int SuccessMessage { get { return 1072361; } } // You engraved the object.
|
|
public virtual int TargetMessage { get { return 1072357; } } // Select an object to engrave.
|
|
public virtual int RemoveMessage { get { return 1072362; } } // You remove the engraving from the object.
|
|
public virtual int ReChargesMessage { get { return 1076166; } } // You do not have a blue diamond needed to recharge the engraving tool.
|
|
public virtual int OutOfChargesMessage { get { return 1076163; } } // There are no charges left on this engraving tool.
|
|
public virtual int NotAccessibleMessage { get { return 1072310; } } // The selected item is not accessible to engrave.
|
|
public virtual int CannotEngraveMessage { get { return 1072309; } } // The selected item cannot be engraved by this engraving tool.
|
|
public virtual int ObjectWasNotMessage { get { return 1072363; } } // The object was not engraved.
|
|
|
|
public virtual bool CheckType(IEntity entity)
|
|
{
|
|
if (Engraves == null || entity == null)
|
|
return false;
|
|
|
|
Type type = entity.GetType();
|
|
|
|
for (int i = 0; i < Engraves.Length; i++)
|
|
{
|
|
if (type == Engraves[i] || type.IsSubclassOf(Engraves[i]))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static BaseEngravingTool Find(Mobile from)
|
|
{
|
|
if (from.Backpack != null)
|
|
{
|
|
BaseEngravingTool tool = from.Backpack.FindItemByType(typeof(BaseEngravingTool)) as BaseEngravingTool;
|
|
|
|
if (tool != null && !tool.DeletedItem && tool.UsesRemaining <= 0)
|
|
return tool;
|
|
else
|
|
return null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public override void OnDoubleClick(Mobile from)
|
|
{
|
|
base.OnDoubleClick(from);
|
|
|
|
if (!from.NetState.SupportsExpansion(Expansion.ML))
|
|
{
|
|
from.SendLocalizedMessage(1072791); // You must upgrade to Mondain's Legacy in order to use that item.
|
|
return;
|
|
}
|
|
|
|
if (m_UsesRemaining > 0)
|
|
{
|
|
from.SendLocalizedMessage(TargetMessage);
|
|
from.Target = new InternalTarget(this);
|
|
}
|
|
else
|
|
{
|
|
if (!DeletedItem)
|
|
{
|
|
if (CheckSkill(from))
|
|
{
|
|
Item diamond = from.Backpack.FindItemByType(typeof(BlueDiamond));
|
|
|
|
if (diamond != null)
|
|
{
|
|
from.SendGump(new ConfirmGump(this, null));
|
|
}
|
|
else
|
|
{
|
|
from.SendLocalizedMessage(ReChargesMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
from.SendLocalizedMessage(OutOfChargesMessage);
|
|
}
|
|
}
|
|
|
|
private bool IsValid(IEntity entity, Mobile m)
|
|
{
|
|
if (entity is Item)
|
|
{
|
|
Item item = entity as Item;
|
|
|
|
BaseHouse house = BaseHouse.FindHouseAt(item);
|
|
|
|
if (m.InRange(item.GetWorldLocation(), 3))
|
|
{
|
|
if (item.Movable && !item.IsLockedDown && !item.IsSecure && (item.RootParent == null || item.RootParent == m))
|
|
{
|
|
return true;
|
|
}
|
|
else if (house != null && house.IsFriend(m))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else if (entity is BaseCreature)
|
|
{
|
|
BaseCreature bc = entity as BaseCreature;
|
|
|
|
if (bc.Controlled && bc.ControlMaster == m)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool CheckSkill(Mobile from)
|
|
{
|
|
if (from.Skills[SkillName.Tinkering].Value < 75.0)
|
|
{
|
|
from.SendLocalizedMessage(LowSkillMessage);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public virtual void Recharge(Mobile from, Mobile guildmaster)
|
|
{
|
|
if (from.Backpack != null)
|
|
{
|
|
Item diamond = from.Backpack.FindItemByType(typeof(BlueDiamond));
|
|
|
|
if (guildmaster != null)
|
|
{
|
|
if (m_UsesRemaining <= 0)
|
|
{
|
|
if (diamond != null && Banker.Withdraw(from, 100000))
|
|
{
|
|
diamond.Consume();
|
|
UsesRemaining = 10;
|
|
guildmaster.Say(1076165); // Your weapon engraver should be good as new!
|
|
}
|
|
else
|
|
guildmaster.Say(1076167); // You need a 100,000 gold and a blue diamond to recharge the weapon engraver.
|
|
}
|
|
else
|
|
guildmaster.Say(1076164); // I can only help with this if you are carrying an engraving tool that needs repair.
|
|
}
|
|
else
|
|
{
|
|
if (CheckSkill(from))
|
|
{
|
|
if (diamond != null)
|
|
{
|
|
diamond.Consume();
|
|
|
|
if (Utility.RandomDouble() < from.Skills[SkillName.Tinkering].Value / 100)
|
|
{
|
|
UsesRemaining = 10;
|
|
from.SendLocalizedMessage(1076165); // Your engraver should be good as new!
|
|
}
|
|
else
|
|
from.SendLocalizedMessage(1076175); // You cracked the diamond attempting to fix the engraver.
|
|
}
|
|
else
|
|
from.SendLocalizedMessage(1076166); // You do not have a blue diamond needed to recharge the engraving tool.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void GetProperties(ObjectPropertyList list)
|
|
{
|
|
base.GetProperties(list);
|
|
|
|
if (m_IsRewardItem)
|
|
list.Add(VeteranRewardCliloc);
|
|
}
|
|
|
|
public override void AddUsesRemainingProperties(ObjectPropertyList list)
|
|
{
|
|
if (ShowUsesRemaining)
|
|
{
|
|
list.Add(1060584, m_UsesRemaining.ToString()); // uses remaining: ~1_val~
|
|
}
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)2); // version
|
|
|
|
writer.Write((int)m_UsesRemaining);
|
|
writer.Write((bool)m_IsRewardItem);
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
|
|
switch (version)
|
|
{
|
|
case 2:
|
|
{
|
|
m_UsesRemaining = reader.ReadInt();
|
|
m_IsRewardItem = reader.ReadBool();
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
m_UsesRemaining = reader.ReadInt();
|
|
break;
|
|
}
|
|
case 0:
|
|
{
|
|
if (this is WeaponEngravingTool)
|
|
{
|
|
InheritsItem = true;
|
|
m_UsesRemaining = reader.ReadInt();
|
|
m_IsRewardItem = reader.ReadBool();
|
|
}
|
|
else
|
|
{
|
|
LootType = LootType.Blessed;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Old Item Serialization Vars
|
|
/* DO NOT USE! Only used in serialization of Weapon Engraving Tool that originally derived from Item */
|
|
public bool InheritsItem { get; protected set; }
|
|
#endregion
|
|
|
|
private class InternalTarget : Target
|
|
{
|
|
private readonly BaseEngravingTool m_Tool;
|
|
|
|
public InternalTarget(BaseEngravingTool tool)
|
|
: base(3, true, TargetFlags.None)
|
|
{
|
|
m_Tool = tool;
|
|
}
|
|
|
|
protected override void OnTarget(Mobile from, object targeted)
|
|
{
|
|
if (m_Tool == null || m_Tool.Deleted)
|
|
return;
|
|
|
|
if (targeted is IEntity)
|
|
{
|
|
IEntity entity = (IEntity)targeted;
|
|
|
|
if (m_Tool.IsValid(entity, from))
|
|
{
|
|
if (entity is IEngravable && m_Tool.CheckType(entity))
|
|
{
|
|
from.CloseGump(typeof(InternalGump));
|
|
from.SendGump(new InternalGump(m_Tool, entity));
|
|
}
|
|
else
|
|
from.SendLocalizedMessage(m_Tool.CannotEngraveMessage);
|
|
}
|
|
else
|
|
from.SendLocalizedMessage(m_Tool.CannotEngraveMessage);
|
|
}
|
|
else
|
|
from.SendLocalizedMessage(m_Tool.CannotEngraveMessage);
|
|
}
|
|
|
|
protected override void OnTargetOutOfRange(Mobile from, object targeted)
|
|
{
|
|
from.SendLocalizedMessage(m_Tool.NotAccessibleMessage);
|
|
}
|
|
}
|
|
|
|
public class ConfirmGump : Gump
|
|
{
|
|
private readonly BaseEngravingTool Tool;
|
|
private readonly Mobile m_NPC;
|
|
|
|
public ConfirmGump(BaseEngravingTool tool, Mobile npc)
|
|
: base(200, 200)
|
|
{
|
|
Tool = tool;
|
|
m_NPC = npc;
|
|
|
|
AddPage(0);
|
|
|
|
AddBackground(0, 0, 291, 133, 0x13BE);
|
|
AddImageTiled(5, 5, 280, 100, 0xA40);
|
|
|
|
if (npc != null)
|
|
{
|
|
AddHtmlLocalized(9, 9, 272, 100, 1076169, 0x7FFF, false, false); // It will cost you 100,000 gold and a blue diamond to recharge your weapon engraver with 10 charges.
|
|
AddHtmlLocalized(195, 109, 120, 20, 1076172, 0x7FFF, false, false); // Recharge it
|
|
}
|
|
else
|
|
{
|
|
AddHtmlLocalized(9, 9, 272, 100, 1076176, 0x7FFF, false, false); // You will need a blue diamond to repair the tip of the engraver. A successful repair will give the engraver 10 charges.
|
|
AddHtmlLocalized(195, 109, 120, 20, 1076177, 0x7FFF, false, false); // Replace the tip.
|
|
}
|
|
|
|
AddButton(160, 107, 0xFB7, 0xFB8, 1, GumpButtonType.Reply, 0);
|
|
AddButton(5, 107, 0xFB1, 0xFB2, 0, GumpButtonType.Reply, 0);
|
|
AddHtmlLocalized(40, 109, 100, 20, 1060051, 0x7FFF, false, false); // CANCEL
|
|
}
|
|
|
|
public override void OnResponse(NetState state, RelayInfo info)
|
|
{
|
|
if (Tool == null || Tool.Deleted)
|
|
return;
|
|
|
|
if (info.ButtonID == 1)
|
|
Tool.Recharge(state.Mobile, m_NPC);
|
|
}
|
|
}
|
|
|
|
private class InternalGump : Gump
|
|
{
|
|
private readonly BaseEngravingTool m_Tool;
|
|
private readonly IEntity m_Target;
|
|
|
|
public InternalGump(BaseEngravingTool tool, IEntity target)
|
|
: base(0, 0)
|
|
{
|
|
m_Tool = tool;
|
|
m_Target = target;
|
|
|
|
AddBackground(50, 50, 400, 300, 0xA28);
|
|
|
|
AddPage(0);
|
|
|
|
AddHtmlLocalized(50, 70, 400, 20, m_Tool.GumpTitle, 0x0, false, false);
|
|
AddHtmlLocalized(75, 95, 350, 145, 1072360, 0x0, true, true);
|
|
|
|
AddButton(125, 300, 0x81A, 0x81B, 1, GumpButtonType.Reply, 0);
|
|
AddButton(320, 300, 0x819, 0x818, 0, GumpButtonType.Reply, 0);
|
|
|
|
AddImageTiled(75, 245, 350, 40, 0xDB0);
|
|
AddImageTiled(76, 245, 350, 2, 0x23C5);
|
|
AddImageTiled(75, 245, 2, 40, 0x23C3);
|
|
AddImageTiled(75, 285, 350, 2, 0x23C5);
|
|
AddImageTiled(425, 245, 2, 42, 0x23C3);
|
|
|
|
AddTextEntry(78, 246, 343, 37, 0x4FF, 15, "", 78);
|
|
}
|
|
|
|
public override void OnResponse(NetState state, RelayInfo info)
|
|
{
|
|
if (m_Tool == null || m_Tool.Deleted || m_Target == null || m_Target.Deleted)
|
|
return;
|
|
|
|
Mobile from = state.Mobile;
|
|
|
|
if (info.ButtonID == 1)
|
|
{
|
|
if (!m_Tool.IsChildOf(from.Backpack))
|
|
{
|
|
from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.
|
|
return;
|
|
}
|
|
else if (!m_Tool.IsValid(m_Target, from))
|
|
{
|
|
from.SendLocalizedMessage(1072311); // The engraving failed.
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
TextRelay relay = info.GetTextEntry(15);
|
|
|
|
IEngravable item = (IEngravable)m_Target;
|
|
|
|
if (relay != null)
|
|
{
|
|
if (relay.Text == null || relay.Text.Equals(""))
|
|
{
|
|
if (item.EngravedText != null)
|
|
{
|
|
item.EngravedText = null;
|
|
from.SendLocalizedMessage(m_Tool.RemoveMessage);
|
|
}
|
|
else
|
|
{
|
|
from.SendLocalizedMessage(m_Tool.ObjectWasNotMessage);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string text;
|
|
|
|
if (relay.Text.Length > 40)
|
|
text = relay.Text.Substring(0, 40);
|
|
else
|
|
text = relay.Text;
|
|
|
|
item.EngravedText = text;
|
|
|
|
from.SendLocalizedMessage(m_Tool.SuccessMessage);
|
|
|
|
m_Tool.UsesRemaining--;
|
|
|
|
if (m_Tool.UsesRemaining < 1)
|
|
{
|
|
if (m_Tool.DeletedItem)
|
|
{
|
|
m_Tool.Delete();
|
|
from.SendLocalizedMessage(1044038); // You have worn out your tool!
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class LeatherContainerEngraver : BaseEngravingTool
|
|
{
|
|
[Constructable]
|
|
public LeatherContainerEngraver()
|
|
: base(0xF9D, 1)
|
|
{
|
|
}
|
|
|
|
public LeatherContainerEngraver(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override int LabelNumber
|
|
{
|
|
get
|
|
{
|
|
return 1072152;
|
|
}
|
|
}// leather container engraving tool
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(Pouch), typeof(Backpack), typeof(Bag)
|
|
};
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class WoodenContainerEngraver : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1072153; } } // wooden container engraving tool
|
|
|
|
[Constructable]
|
|
public WoodenContainerEngraver()
|
|
: base(0x1026, 1)
|
|
{
|
|
}
|
|
|
|
public WoodenContainerEngraver(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(WoodenBox), typeof(LargeCrate), typeof(MediumCrate),
|
|
typeof(SmallCrate), typeof(WoodenChest), typeof(EmptyBookcase),
|
|
typeof(Armoire), typeof(FancyArmoire), typeof(PlainWoodenChest),
|
|
typeof(OrnateWoodenChest), typeof(GildedWoodenChest), typeof(WoodenFootLocker),
|
|
typeof(FinishedWoodenChest), typeof(TallCabinet), typeof(ShortCabinet),
|
|
typeof(RedArmoire), typeof(CherryArmoire), typeof(MapleArmoire),
|
|
typeof(ElegantArmoire), typeof(Keg), typeof(SimpleElvenArmoire),
|
|
typeof(DecorativeBox), typeof(FancyElvenArmoire), typeof(RarewoodChest),
|
|
typeof(RewardSign), typeof(GargoyleWoodenChest)
|
|
};
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class MetalContainerEngraver : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1072154; } } // metal container engraving tool
|
|
|
|
[Constructable]
|
|
public MetalContainerEngraver()
|
|
: base(0x1EB8, 1)
|
|
{
|
|
}
|
|
|
|
public MetalContainerEngraver(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(ParagonChest), typeof(MetalChest), typeof(MetalGoldenChest), typeof(MetalBox)
|
|
};
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class FoodEngraver : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1072951; } } // food decoration tool
|
|
|
|
[Constructable]
|
|
public FoodEngraver()
|
|
: base(0x1BD1, 1)
|
|
{
|
|
}
|
|
|
|
public FoodEngraver(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(Cake), typeof(CheesePizza), typeof(SausagePizza),
|
|
typeof(Cookies)
|
|
};
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class SpellbookEngraver : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1072151; } } // spellbook engraving tool
|
|
|
|
[Constructable]
|
|
public SpellbookEngraver()
|
|
: base(0xFBF, 1)
|
|
{
|
|
}
|
|
|
|
public SpellbookEngraver(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(Spellbook)
|
|
};
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class StatuetteEngravingTool : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1080201; } } // Statuette Engraving Tool
|
|
|
|
[Constructable]
|
|
public StatuetteEngravingTool()
|
|
: base(0x12B3, 10)
|
|
{
|
|
Hue = 0;
|
|
}
|
|
|
|
public StatuetteEngravingTool(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(MonsterStatuette)
|
|
};
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class ArmorEngravingTool : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1080547; } }// Armor Engraving Tool
|
|
|
|
[Constructable]
|
|
public ArmorEngravingTool()
|
|
: base(0x32F8, 30)
|
|
{
|
|
Hue = 0x490;
|
|
}
|
|
|
|
public ArmorEngravingTool(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override int GumpTitle { get { return 1071163; } } // <center>Armor Engraving Tool</center>
|
|
|
|
public override Type[] Engraves { get { return new Type[] { typeof(BaseArmor) }; } }
|
|
|
|
public override bool CheckType(IEntity entity)
|
|
{
|
|
bool check = base.CheckType(entity);
|
|
|
|
if (check && entity.GetType().IsSubclassOf(typeof(BaseShield)))
|
|
{
|
|
check = false;
|
|
}
|
|
|
|
return check;
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
int version = reader.ReadInt();
|
|
}
|
|
}
|
|
|
|
public class ShieldEngravingTool : BaseEngravingTool
|
|
{
|
|
public override int LabelNumber { get { return 1159004; } } // Shield Engraving Tool
|
|
|
|
public override bool DeletedItem { get { return false; } }
|
|
public override int LowSkillMessage { get { return 1076178; } } // // Your tinkering skill is too low to fix this yourself. An NPC tinkerer can help you repair this for a fee.
|
|
public override int VeteranRewardCliloc { get { return 0; } }
|
|
|
|
[Constructable]
|
|
public ShieldEngravingTool()
|
|
: base(0x1EB8, 10)
|
|
{
|
|
Hue = 1165;
|
|
}
|
|
|
|
public ShieldEngravingTool(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public override Type[] Engraves
|
|
{
|
|
get
|
|
{
|
|
return new Type[]
|
|
{
|
|
typeof(BaseShield)
|
|
};
|
|
}
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
writer.Write((int)0); // version
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
reader.ReadInt();
|
|
}
|
|
}
|
|
}
|