unstableKitsune/abysmal-isle
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Overwrite

Browse Source 
Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.
This commit is contained in:
Unstable Kitsune
2023-11-28 23:20:26 -05:00
parent 3cd54811de
commit b918192e4e
11608 changed files with 2644205 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

827
Scripts/Items/Consumables/EngravingTools.cs Normal file
View File

@@ -0,0 +1,827 @@
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();
}
}
}