1179 lines
31 KiB
C#
1179 lines
31 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using Server.Network;
|
|
using Server.Engines.Craft;
|
|
using AMA = Server.Items.ArmorMeditationAllowance;
|
|
using AMT = Server.Items.ArmorMaterialType;
|
|
using ABT = Server.Items.ArmorBodyType;
|
|
|
|
namespace Server.Items
|
|
{
|
|
public abstract class BaseArmor : Item, IScissorable, ICraftable, IWearableDurability
|
|
{
|
|
/* Armor internals work differently now (Jun 19 2003)
|
|
*
|
|
* The attributes defined below default to -1.
|
|
* If the value is -1, the corresponding virtual property is used.
|
|
* If not, the attribute value itself is used. Here's the list:
|
|
* - ArmorBase
|
|
* - StrBonus
|
|
* - DexBonus
|
|
* - IntBonus
|
|
* - StrReq
|
|
* - DexReq
|
|
* - IntReq
|
|
* - MeditationAllowance
|
|
*/
|
|
|
|
// Instance values. These values must are unique to each armor piece.
|
|
private int m_MaxHitPoints;
|
|
private int m_HitPoints;
|
|
private Mobile m_Crafter;
|
|
private ArmorQuality m_Quality;
|
|
private ArmorDurabilityLevel m_Durability;
|
|
private ArmorProtectionLevel m_Protection;
|
|
private CraftResource m_Resource;
|
|
private bool m_PlayerConstructed;
|
|
|
|
// Overridable values. These values are provided to override the defaults which get defined in the individual armor scripts.
|
|
private int m_ArmorBase = -1;
|
|
private int m_StrBonus = -1, m_DexBonus = -1, m_IntBonus = -1;
|
|
private int m_StrReq = -1, m_DexReq = -1, m_IntReq = -1;
|
|
private AMA m_Meditate = (AMA)(-1);
|
|
|
|
public virtual bool AllowMaleWearer{ get{ return true; } }
|
|
public virtual bool AllowFemaleWearer{ get{ return true; } }
|
|
|
|
public abstract AMT MaterialType{ get; }
|
|
|
|
public virtual int RevertArmorBase{ get{ return ArmorBase; } }
|
|
public virtual int ArmorBase{ get{ return 0; } }
|
|
|
|
public virtual AMA DefMedAllowance{ get{ return AMA.None; } }
|
|
public virtual AMA UOMedAllowance{ get{ return DefMedAllowance; } }
|
|
|
|
public virtual int UOStrBonus{ get{ return 0; } }
|
|
public virtual int UODexBonus{ get{ return 0; } }
|
|
public virtual int UOIntBonus{ get{ return 0; } }
|
|
public virtual int UOStrReq{ get{ return 0; } }
|
|
public virtual int UODexReq{ get{ return 0; } }
|
|
public virtual int UOIntReq{ get{ return 0; } }
|
|
|
|
public virtual bool CanFortify{ get{ return true; } }
|
|
|
|
public override void OnAfterDuped( Item newItem )
|
|
{
|
|
BaseArmor armor = newItem as BaseArmor;
|
|
|
|
if ( armor == null )
|
|
return;
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public AMA MeditationAllowance
|
|
{
|
|
get{ return ( m_Meditate == (AMA)(-1) ? UOMedAllowance : m_Meditate ); }
|
|
set{ m_Meditate = value; }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int BaseArmorRating
|
|
{
|
|
get
|
|
{
|
|
if ( m_ArmorBase == -1 )
|
|
return ArmorBase;
|
|
else
|
|
return m_ArmorBase;
|
|
}
|
|
set
|
|
{
|
|
m_ArmorBase = value; Invalidate();
|
|
}
|
|
}
|
|
|
|
public double BaseArmorRatingScaled
|
|
{
|
|
get
|
|
{
|
|
return ( BaseArmorRating * ArmorScalar );
|
|
}
|
|
}
|
|
|
|
public virtual double ArmorRating
|
|
{
|
|
get
|
|
{
|
|
int ar = BaseArmorRating;
|
|
|
|
if ( m_Protection != ArmorProtectionLevel.Regular )
|
|
ar += 10 + (5 * (int)m_Protection);
|
|
|
|
ar += -8 + (8 * (int)m_Quality);
|
|
return ScaleArmorByDurability( ar );
|
|
}
|
|
}
|
|
|
|
public double ArmorRatingScaled
|
|
{
|
|
get
|
|
{
|
|
return ( ArmorRating * ArmorScalar );
|
|
}
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int StrBonus
|
|
{
|
|
get{ return ( m_StrBonus == -1 ? UOStrBonus : m_StrBonus ); }
|
|
set{ m_StrBonus = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int DexBonus
|
|
{
|
|
get{ return ( m_DexBonus == -1 ? UODexBonus : m_DexBonus ); }
|
|
set{ m_DexBonus = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int IntBonus
|
|
{
|
|
get{ return ( m_IntBonus == -1 ? UOIntBonus : m_IntBonus ); }
|
|
set{ m_IntBonus = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int StrRequirement
|
|
{
|
|
get{ return ( m_StrReq == -1 ? UOStrReq : m_StrReq ); }
|
|
set{ m_StrReq = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int DexRequirement
|
|
{
|
|
get{ return ( m_DexReq == -1 ? UODexReq : m_DexReq ); }
|
|
set{ m_DexReq = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int IntRequirement
|
|
{
|
|
get{ return ( m_IntReq == -1 ? UOIntReq : m_IntReq ); }
|
|
set{ m_IntReq = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public bool PlayerConstructed
|
|
{
|
|
get{ return m_PlayerConstructed; }
|
|
set{ m_PlayerConstructed = value; }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public CraftResource Resource
|
|
{
|
|
get
|
|
{
|
|
return m_Resource;
|
|
}
|
|
set
|
|
{
|
|
if ( m_Resource != value )
|
|
{
|
|
UnscaleDurability();
|
|
|
|
m_Resource = value;
|
|
|
|
if (!DefTailoring.IsNonColorable(this.GetType()))
|
|
{
|
|
Hue = CraftResources.GetHue(m_Resource);
|
|
}
|
|
|
|
Invalidate();
|
|
InvalidateProperties();
|
|
|
|
ScaleDurability();
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual double ArmorScalar
|
|
{
|
|
get
|
|
{
|
|
int pos = (int)BodyPosition;
|
|
|
|
if ( pos >= 0 && pos < m_ArmorScalars.Length )
|
|
return m_ArmorScalars[pos];
|
|
|
|
return 1.0;
|
|
}
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int MaxHitPoints
|
|
{
|
|
get{ return m_MaxHitPoints; }
|
|
set{ m_MaxHitPoints = value; InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public int HitPoints
|
|
{
|
|
get
|
|
{
|
|
return m_HitPoints;
|
|
}
|
|
set
|
|
{
|
|
if ( value != m_HitPoints && MaxHitPoints > 0 )
|
|
{
|
|
m_HitPoints = value;
|
|
|
|
if ( m_HitPoints < 0 )
|
|
Delete();
|
|
else if ( m_HitPoints > MaxHitPoints )
|
|
m_HitPoints = MaxHitPoints;
|
|
|
|
InvalidateProperties();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public Mobile Crafter
|
|
{
|
|
get{ return m_Crafter; }
|
|
set{ m_Crafter = value; InvalidateProperties(); }
|
|
}
|
|
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public ArmorQuality Quality
|
|
{
|
|
get{ return m_Quality; }
|
|
set{ UnscaleDurability(); m_Quality = value; Invalidate(); InvalidateProperties(); ScaleDurability(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public ArmorDurabilityLevel Durability
|
|
{
|
|
get{ return m_Durability; }
|
|
set{ UnscaleDurability(); m_Durability = value; ScaleDurability(); InvalidateProperties(); }
|
|
}
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public ArmorProtectionLevel ProtectionLevel
|
|
{
|
|
get
|
|
{
|
|
return m_Protection;
|
|
}
|
|
set
|
|
{
|
|
if ( m_Protection != value )
|
|
{
|
|
m_Protection = value;
|
|
|
|
Invalidate();
|
|
InvalidateProperties();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int ComputeStatReq( StatType type )
|
|
{
|
|
int v;
|
|
|
|
if ( type == StatType.Str )
|
|
v = StrRequirement;
|
|
else if ( type == StatType.Dex )
|
|
v = DexRequirement;
|
|
else
|
|
v = IntRequirement;
|
|
|
|
return Ultima.Scale( v, 100 - GetLowerStatReq() );
|
|
}
|
|
|
|
public int ComputeStatBonus( StatType type )
|
|
{
|
|
if ( type == StatType.Str )
|
|
return StrBonus;
|
|
else if ( type == StatType.Dex )
|
|
return DexBonus;
|
|
else
|
|
return IntBonus;
|
|
}
|
|
|
|
public virtual int InitMinHits{ get{ return 0; } }
|
|
public virtual int InitMaxHits{ get{ return 0; } }
|
|
|
|
[CommandProperty( AccessLevel.GameMaster )]
|
|
public ArmorBodyType BodyPosition
|
|
{
|
|
get
|
|
{
|
|
switch ( this.Layer )
|
|
{
|
|
default:
|
|
case Layer.Neck: return ArmorBodyType.Gorget;
|
|
case Layer.TwoHanded: return ArmorBodyType.Shield;
|
|
case Layer.Gloves: return ArmorBodyType.Gloves;
|
|
case Layer.Helm: return ArmorBodyType.Helmet;
|
|
case Layer.Arms: return ArmorBodyType.Arms;
|
|
|
|
case Layer.InnerLegs:
|
|
case Layer.OuterLegs:
|
|
case Layer.Pants: return ArmorBodyType.Legs;
|
|
|
|
case Layer.InnerTorso:
|
|
case Layer.OuterTorso:
|
|
case Layer.Shirt: return ArmorBodyType.Chest;
|
|
}
|
|
}
|
|
}
|
|
|
|
public CraftAttributeInfo GetResourceAttrs()
|
|
{
|
|
CraftResourceInfo info = CraftResources.GetInfo( m_Resource );
|
|
|
|
if ( info == null )
|
|
return CraftAttributeInfo.Blank;
|
|
|
|
return info.AttributeInfo;
|
|
}
|
|
|
|
public int GetProtOffset()
|
|
{
|
|
switch ( m_Protection )
|
|
{
|
|
case ArmorProtectionLevel.Guarding: return 1;
|
|
case ArmorProtectionLevel.Hardening: return 2;
|
|
case ArmorProtectionLevel.Fortification: return 3;
|
|
case ArmorProtectionLevel.Invulnerability: return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public void UnscaleDurability()
|
|
{
|
|
int scale = 100 + GetDurabilityBonus();
|
|
|
|
m_HitPoints = ((m_HitPoints * 100) + (scale - 1)) / scale;
|
|
m_MaxHitPoints = ((m_MaxHitPoints * 100) + (scale - 1)) / scale;
|
|
InvalidateProperties();
|
|
}
|
|
|
|
public void ScaleDurability()
|
|
{
|
|
int scale = 100 + GetDurabilityBonus();
|
|
|
|
m_HitPoints = ((m_HitPoints * scale) + 99) / 100;
|
|
m_MaxHitPoints = ((m_MaxHitPoints * scale) + 99) / 100;
|
|
InvalidateProperties();
|
|
}
|
|
|
|
public int GetDurabilityBonus()
|
|
{
|
|
int bonus = 0;
|
|
|
|
if ( m_Quality == ArmorQuality.Exceptional )
|
|
bonus += 20;
|
|
|
|
switch ( m_Durability )
|
|
{
|
|
case ArmorDurabilityLevel.Durable: bonus += 20; break;
|
|
case ArmorDurabilityLevel.Substantial: bonus += 50; break;
|
|
case ArmorDurabilityLevel.Massive: bonus += 70; break;
|
|
case ArmorDurabilityLevel.Fortified: bonus += 100; break;
|
|
case ArmorDurabilityLevel.Indestructible: bonus += 120; break;
|
|
}
|
|
|
|
return bonus;
|
|
}
|
|
|
|
public bool Scissor( Mobile from, Scissors scissors )
|
|
{
|
|
if ( !IsChildOf( from.Backpack ) )
|
|
{
|
|
from.SendLocalizedMessage( 502437 ); // Items you wish to cut must be in your backpack.
|
|
return false;
|
|
}
|
|
|
|
CraftSystem system = DefTailoring.CraftSystem;
|
|
|
|
CraftItem item = system.CraftItems.SearchFor( GetType() );
|
|
|
|
if ( item != null && item.Resources.Count == 1 && item.Resources.GetAt( 0 ).Amount >= 2 )
|
|
{
|
|
try
|
|
{
|
|
Item res = (Item)Activator.CreateInstance( CraftResources.GetInfo( m_Resource ).ResourceTypes[0] );
|
|
|
|
ScissorHelper( from, res, m_PlayerConstructed ? (item.Resources.GetAt( 0 ).Amount / 2) : 1 );
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
from.SendLocalizedMessage( 502440 ); // Scissors can not be used on that to produce anything.
|
|
return false;
|
|
}
|
|
|
|
private static double[] m_ArmorScalars = { 0.07, 0.07, 0.14, 0.15, 0.22, 0.35 };
|
|
|
|
public static double[] ArmorScalars
|
|
{
|
|
get
|
|
{
|
|
return m_ArmorScalars;
|
|
}
|
|
set
|
|
{
|
|
m_ArmorScalars = value;
|
|
}
|
|
}
|
|
|
|
public static void ValidateMobile( Mobile m )
|
|
{
|
|
for ( int i = m.Items.Count - 1; i >= 0; --i )
|
|
{
|
|
if ( i >= m.Items.Count )
|
|
continue;
|
|
|
|
Item item = m.Items[i];
|
|
|
|
if ( item is BaseArmor )
|
|
{
|
|
BaseArmor armor = (BaseArmor)item;
|
|
|
|
if ( !armor.AllowMaleWearer && !m.Female && m.AccessLevel < AccessLevel.GameMaster )
|
|
{
|
|
if ( armor.AllowFemaleWearer )
|
|
m.SendLocalizedMessage( 1010388 ); // Only females can wear this.
|
|
else
|
|
m.SendMessage( "You may not wear this." );
|
|
|
|
m.AddToBackpack( armor );
|
|
}
|
|
else if ( !armor.AllowFemaleWearer && m.Female && m.AccessLevel < AccessLevel.GameMaster )
|
|
{
|
|
if ( armor.AllowMaleWearer )
|
|
m.SendLocalizedMessage( 1063343 ); // Only males can wear this.
|
|
else
|
|
m.SendMessage( "You may not wear this." );
|
|
|
|
m.AddToBackpack( armor );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int GetLowerStatReq()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
public override void OnAdded( object parent )
|
|
{
|
|
if ( parent is Mobile )
|
|
{
|
|
Mobile from = (Mobile)parent;
|
|
|
|
from.Delta( MobileDelta.Armor ); // Tell them armor rating has changed
|
|
}
|
|
}
|
|
|
|
public virtual double ScaleArmorByDurability( double armor )
|
|
{
|
|
int scale = 100;
|
|
|
|
if ( m_MaxHitPoints > 0 && m_HitPoints < m_MaxHitPoints )
|
|
scale = 50 + ((50 * m_HitPoints) / m_MaxHitPoints);
|
|
|
|
return ( armor * scale ) / 100;
|
|
}
|
|
|
|
protected void Invalidate()
|
|
{
|
|
if ( Parent is Mobile )
|
|
((Mobile)Parent).Delta( MobileDelta.Armor ); // Tell them armor rating has changed
|
|
}
|
|
|
|
public BaseArmor( Serial serial ) : base( serial )
|
|
{
|
|
}
|
|
|
|
private static void SetSaveFlag( ref SaveFlag flags, SaveFlag toSet, bool setIf )
|
|
{
|
|
if ( setIf )
|
|
flags |= toSet;
|
|
}
|
|
|
|
private static bool GetSaveFlag( SaveFlag flags, SaveFlag toGet )
|
|
{
|
|
return ( (flags & toGet) != 0 );
|
|
}
|
|
|
|
[Flags]
|
|
private enum SaveFlag
|
|
{
|
|
None = 0x00000000,
|
|
MaxHitPoints = 0x00000001,
|
|
HitPoints = 0x00000002,
|
|
Crafter = 0x00000004,
|
|
Quality = 0x00000008,
|
|
Durability = 0x00000010,
|
|
Protection = 0x00000020,
|
|
Resource = 0x00000040,
|
|
BaseArmor = 0x00000080,
|
|
StrBonus = 0x00000100,
|
|
DexBonus = 0x00000200,
|
|
IntBonus = 0x00000400,
|
|
StrReq = 0x00000800,
|
|
DexReq = 0x00001000,
|
|
IntReq = 0x00002000,
|
|
MedAllowance = 0x00004000,
|
|
SkillBonuses = 0x00008000,
|
|
PlayerConstructed = 0x00010000
|
|
}
|
|
|
|
public override void Serialize( GenericWriter writer )
|
|
{
|
|
base.Serialize( writer );
|
|
|
|
writer.Write( (int) 7 ); // version
|
|
|
|
SaveFlag flags = SaveFlag.None;
|
|
|
|
SetSaveFlag( ref flags, SaveFlag.MaxHitPoints, m_MaxHitPoints != 0 );
|
|
SetSaveFlag( ref flags, SaveFlag.HitPoints, m_HitPoints != 0 );
|
|
SetSaveFlag( ref flags, SaveFlag.Crafter, m_Crafter != null );
|
|
SetSaveFlag( ref flags, SaveFlag.Quality, m_Quality != ArmorQuality.Regular );
|
|
SetSaveFlag( ref flags, SaveFlag.Durability, m_Durability != ArmorDurabilityLevel.Regular );
|
|
SetSaveFlag( ref flags, SaveFlag.Protection, m_Protection != ArmorProtectionLevel.Regular );
|
|
SetSaveFlag( ref flags, SaveFlag.Resource, m_Resource != DefaultResource );
|
|
SetSaveFlag( ref flags, SaveFlag.BaseArmor, m_ArmorBase != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.StrBonus, m_StrBonus != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.DexBonus, m_DexBonus != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.IntBonus, m_IntBonus != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.StrReq, m_StrReq != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.DexReq, m_DexReq != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.IntReq, m_IntReq != -1 );
|
|
SetSaveFlag( ref flags, SaveFlag.MedAllowance, m_Meditate != (AMA)(-1) );
|
|
SetSaveFlag( ref flags, SaveFlag.PlayerConstructed, m_PlayerConstructed != false );
|
|
|
|
writer.WriteEncodedInt( (int) flags );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.MaxHitPoints ) )
|
|
writer.WriteEncodedInt( (int) m_MaxHitPoints );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.HitPoints ) )
|
|
writer.WriteEncodedInt( (int) m_HitPoints );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Crafter ) )
|
|
writer.Write( (Mobile) m_Crafter );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Quality ) )
|
|
writer.WriteEncodedInt( (int) m_Quality );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Durability ) )
|
|
writer.WriteEncodedInt( (int) m_Durability );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Protection ) )
|
|
writer.WriteEncodedInt( (int) m_Protection );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Resource ) )
|
|
writer.WriteEncodedInt( (int) m_Resource );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.BaseArmor ) )
|
|
writer.WriteEncodedInt( (int) m_ArmorBase );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.StrBonus ) )
|
|
writer.WriteEncodedInt( (int) m_StrBonus );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.DexBonus ) )
|
|
writer.WriteEncodedInt( (int) m_DexBonus );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.IntBonus ) )
|
|
writer.WriteEncodedInt( (int) m_IntBonus );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.StrReq ) )
|
|
writer.WriteEncodedInt( (int) m_StrReq );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.DexReq ) )
|
|
writer.WriteEncodedInt( (int) m_DexReq );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.IntReq ) )
|
|
writer.WriteEncodedInt( (int) m_IntReq );
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.MedAllowance ) )
|
|
writer.WriteEncodedInt( (int) m_Meditate );
|
|
}
|
|
|
|
public override void Deserialize( GenericReader reader )
|
|
{
|
|
base.Deserialize( reader );
|
|
|
|
int version = reader.ReadInt();
|
|
|
|
switch ( version )
|
|
{
|
|
case 7:
|
|
case 6:
|
|
case 5:
|
|
{
|
|
SaveFlag flags = (SaveFlag)reader.ReadEncodedInt();
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.MaxHitPoints ) )
|
|
m_MaxHitPoints = reader.ReadEncodedInt();
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.HitPoints ) )
|
|
m_HitPoints = reader.ReadEncodedInt();
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Crafter ) )
|
|
m_Crafter = reader.ReadMobile();
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Quality ) )
|
|
m_Quality = (ArmorQuality)reader.ReadEncodedInt();
|
|
else
|
|
m_Quality = ArmorQuality.Regular;
|
|
|
|
if ( version == 5 && m_Quality == ArmorQuality.Low )
|
|
m_Quality = ArmorQuality.Regular;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Durability ) )
|
|
{
|
|
m_Durability = (ArmorDurabilityLevel)reader.ReadEncodedInt();
|
|
|
|
if ( m_Durability > ArmorDurabilityLevel.Indestructible )
|
|
m_Durability = ArmorDurabilityLevel.Durable;
|
|
}
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Protection ) )
|
|
{
|
|
m_Protection = (ArmorProtectionLevel)reader.ReadEncodedInt();
|
|
|
|
if ( m_Protection > ArmorProtectionLevel.Invulnerability )
|
|
m_Protection = ArmorProtectionLevel.Defense;
|
|
}
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.Resource ) )
|
|
m_Resource = (CraftResource)reader.ReadEncodedInt();
|
|
else
|
|
m_Resource = DefaultResource;
|
|
|
|
if ( m_Resource == CraftResource.None )
|
|
m_Resource = DefaultResource;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.BaseArmor ) )
|
|
m_ArmorBase = reader.ReadEncodedInt();
|
|
else
|
|
m_ArmorBase = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.StrBonus ) )
|
|
m_StrBonus = reader.ReadEncodedInt();
|
|
else
|
|
m_StrBonus = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.DexBonus ) )
|
|
m_DexBonus = reader.ReadEncodedInt();
|
|
else
|
|
m_DexBonus = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.IntBonus ) )
|
|
m_IntBonus = reader.ReadEncodedInt();
|
|
else
|
|
m_IntBonus = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.StrReq ) )
|
|
m_StrReq = reader.ReadEncodedInt();
|
|
else
|
|
m_StrReq = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.DexReq ) )
|
|
m_DexReq = reader.ReadEncodedInt();
|
|
else
|
|
m_DexReq = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.IntReq ) )
|
|
m_IntReq = reader.ReadEncodedInt();
|
|
else
|
|
m_IntReq = -1;
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.MedAllowance ) )
|
|
m_Meditate = (AMA)reader.ReadEncodedInt();
|
|
else
|
|
m_Meditate = (AMA)(-1);
|
|
|
|
if ( GetSaveFlag( flags, SaveFlag.PlayerConstructed ) )
|
|
m_PlayerConstructed = true;
|
|
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
goto case 3;
|
|
}
|
|
case 3:
|
|
{
|
|
goto case 2;
|
|
}
|
|
case 2:
|
|
case 1:
|
|
{
|
|
goto case 0;
|
|
}
|
|
case 0:
|
|
{
|
|
m_ArmorBase = reader.ReadInt();
|
|
m_MaxHitPoints = reader.ReadInt();
|
|
m_HitPoints = reader.ReadInt();
|
|
m_Crafter = reader.ReadMobile();
|
|
m_Quality = (ArmorQuality)reader.ReadInt();
|
|
m_Durability = (ArmorDurabilityLevel)reader.ReadInt();
|
|
m_Protection = (ArmorProtectionLevel)reader.ReadInt();
|
|
|
|
AMT mat = (AMT)reader.ReadInt();
|
|
|
|
if ( m_ArmorBase == RevertArmorBase )
|
|
m_ArmorBase = -1;
|
|
|
|
if ( version >= 2 )
|
|
{
|
|
m_Resource = (CraftResource)reader.ReadInt();
|
|
}
|
|
else
|
|
{
|
|
OreInfo info = OreInfo.Iron;
|
|
m_Resource = CraftResources.GetFromOreInfo( info, mat );
|
|
}
|
|
|
|
m_StrBonus = reader.ReadInt();
|
|
m_DexBonus = reader.ReadInt();
|
|
m_IntBonus = reader.ReadInt();
|
|
m_StrReq = reader.ReadInt();
|
|
m_DexReq = reader.ReadInt();
|
|
m_IntReq = reader.ReadInt();
|
|
|
|
if ( m_StrBonus == UOStrBonus )
|
|
m_StrBonus = -1;
|
|
|
|
if ( m_DexBonus == UODexBonus )
|
|
m_DexBonus = -1;
|
|
|
|
if ( m_IntBonus == UOIntBonus )
|
|
m_IntBonus = -1;
|
|
|
|
if ( m_StrReq == UOStrReq )
|
|
m_StrReq = -1;
|
|
|
|
if ( m_DexReq == UODexReq )
|
|
m_DexReq = -1;
|
|
|
|
if ( m_IntReq == UOIntReq )
|
|
m_IntReq = -1;
|
|
|
|
m_Meditate = (AMA)reader.ReadInt();
|
|
|
|
if ( m_Meditate == UOMedAllowance )
|
|
m_Meditate = (AMA)(-1);
|
|
|
|
if ( m_Resource == CraftResource.None )
|
|
{
|
|
if ( mat == ArmorMaterialType.Studded || mat == ArmorMaterialType.Leather )
|
|
m_Resource = CraftResource.Leathered;
|
|
else if ( mat == ArmorMaterialType.Wood )
|
|
m_Resource = CraftResource.Wooden;
|
|
else
|
|
m_Resource = CraftResource.Iron;
|
|
}
|
|
|
|
if ( m_MaxHitPoints == 0 && m_HitPoints == 0 )
|
|
m_HitPoints = m_MaxHitPoints = Utility.RandomMinMax( InitMinHits, InitMaxHits );
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
int strBonus = ComputeStatBonus( StatType.Str );
|
|
int dexBonus = ComputeStatBonus( StatType.Dex );
|
|
int intBonus = ComputeStatBonus( StatType.Int );
|
|
|
|
if ( Parent is Mobile && (strBonus != 0 || dexBonus != 0 || intBonus != 0) )
|
|
{
|
|
Mobile m = (Mobile)Parent;
|
|
|
|
string modName = Serial.ToString();
|
|
|
|
if ( strBonus != 0 )
|
|
m.AddStatMod( new StatMod( StatType.Str, modName + "Str", strBonus, TimeSpan.Zero ) );
|
|
|
|
if ( dexBonus != 0 )
|
|
m.AddStatMod( new StatMod( StatType.Dex, modName + "Dex", dexBonus, TimeSpan.Zero ) );
|
|
|
|
if ( intBonus != 0 )
|
|
m.AddStatMod( new StatMod( StatType.Int, modName + "Int", intBonus, TimeSpan.Zero ) );
|
|
}
|
|
|
|
if ( Parent is Mobile )
|
|
((Mobile)Parent).CheckStatTimers();
|
|
|
|
if ( version < 7 )
|
|
m_PlayerConstructed = true; // we don't know, so, assume it's crafted
|
|
}
|
|
|
|
public virtual CraftResource DefaultResource{ get{ return CraftResource.Iron; } }
|
|
|
|
public BaseArmor( int itemID ) : base( itemID )
|
|
{
|
|
m_Quality = ArmorQuality.Regular;
|
|
m_Durability = ArmorDurabilityLevel.Regular;
|
|
m_Crafter = null;
|
|
|
|
m_Resource = DefaultResource;
|
|
Hue = CraftResources.GetHue( m_Resource );
|
|
|
|
m_HitPoints = m_MaxHitPoints = Utility.RandomMinMax( InitMinHits, InitMaxHits );
|
|
|
|
this.Layer = (Layer)ItemData.Quality;
|
|
}
|
|
|
|
public override bool CanEquip( Mobile from )
|
|
{
|
|
if( from.AccessLevel < AccessLevel.GameMaster )
|
|
{
|
|
if( !AllowMaleWearer && !from.Female )
|
|
{
|
|
if( AllowFemaleWearer )
|
|
from.SendLocalizedMessage( 1010388 ); // Only females can wear this.
|
|
else
|
|
from.SendMessage( "You may not wear this." );
|
|
|
|
return false;
|
|
}
|
|
else if( !AllowFemaleWearer && from.Female )
|
|
{
|
|
if( AllowMaleWearer )
|
|
from.SendLocalizedMessage( 1063343 ); // Only males can wear this.
|
|
else
|
|
from.SendMessage( "You may not wear this." );
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
int strBonus = ComputeStatBonus( StatType.Str ), strReq = ComputeStatReq( StatType.Str );
|
|
int dexBonus = ComputeStatBonus( StatType.Dex ), dexReq = ComputeStatReq( StatType.Dex );
|
|
int intBonus = ComputeStatBonus( StatType.Int ), intReq = ComputeStatReq( StatType.Int );
|
|
|
|
if( from.Dex < dexReq || (from.Dex + dexBonus) < 1 )
|
|
{
|
|
from.SendLocalizedMessage( 502077 ); // You do not have enough dexterity to equip this item.
|
|
return false;
|
|
}
|
|
else if( from.Str < strReq || (from.Str + strBonus) < 1 )
|
|
{
|
|
from.SendLocalizedMessage( 500213 ); // You are not strong enough to equip that.
|
|
return false;
|
|
}
|
|
else if( from.Int < intReq || (from.Int + intBonus) < 1 )
|
|
{
|
|
from.SendMessage( "You are not smart enough to equip that." );
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return base.CanEquip( from );
|
|
}
|
|
|
|
public override bool CheckPropertyConfliction( Mobile m )
|
|
{
|
|
if ( base.CheckPropertyConfliction( m ) )
|
|
return true;
|
|
|
|
if ( Layer == Layer.Pants )
|
|
return ( m.FindItemOnLayer( Layer.InnerLegs ) != null );
|
|
|
|
if ( Layer == Layer.Shirt )
|
|
return ( m.FindItemOnLayer( Layer.InnerTorso ) != null );
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool OnEquip( Mobile from )
|
|
{
|
|
from.CheckStatTimers();
|
|
|
|
int strBonus = ComputeStatBonus( StatType.Str );
|
|
int dexBonus = ComputeStatBonus( StatType.Dex );
|
|
int intBonus = ComputeStatBonus( StatType.Int );
|
|
|
|
if ( strBonus != 0 || dexBonus != 0 || intBonus != 0 )
|
|
{
|
|
string modName = this.Serial.ToString();
|
|
|
|
if ( strBonus != 0 )
|
|
from.AddStatMod( new StatMod( StatType.Str, modName + "Str", strBonus, TimeSpan.Zero ) );
|
|
|
|
if ( dexBonus != 0 )
|
|
from.AddStatMod( new StatMod( StatType.Dex, modName + "Dex", dexBonus, TimeSpan.Zero ) );
|
|
|
|
if ( intBonus != 0 )
|
|
from.AddStatMod( new StatMod( StatType.Int, modName + "Int", intBonus, TimeSpan.Zero ) );
|
|
}
|
|
|
|
return base.OnEquip( from );
|
|
}
|
|
|
|
public override void OnRemoved( object parent )
|
|
{
|
|
if ( parent is Mobile )
|
|
{
|
|
Mobile m = (Mobile)parent;
|
|
string modName = this.Serial.ToString();
|
|
|
|
m.RemoveStatMod( modName + "Str" );
|
|
m.RemoveStatMod( modName + "Dex" );
|
|
m.RemoveStatMod( modName + "Int" );
|
|
|
|
((Mobile)parent).Delta( MobileDelta.Armor ); // Tell them armor rating has changed
|
|
m.CheckStatTimers();
|
|
}
|
|
|
|
base.OnRemoved( parent );
|
|
}
|
|
|
|
public virtual int OnHit( BaseWeapon weapon, int damageTaken )
|
|
{
|
|
double HalfAr = ArmorRating / 2.0;
|
|
int Absorbed = (int)(HalfAr + HalfAr*Utility.RandomDouble());
|
|
|
|
damageTaken -= Absorbed;
|
|
if ( damageTaken < 0 )
|
|
damageTaken = 0;
|
|
|
|
if ( Absorbed < 2 )
|
|
Absorbed = 2;
|
|
|
|
if ( 25 > Utility.Random( 100 ) ) // 25% chance to lower durability
|
|
{
|
|
int wear;
|
|
|
|
if ( weapon.Type == WeaponType.Bashing )
|
|
wear = Absorbed / 2;
|
|
else
|
|
wear = Utility.Random( 2 );
|
|
|
|
if ( wear > 0 && m_MaxHitPoints > 0 )
|
|
{
|
|
if ( m_HitPoints >= wear )
|
|
{
|
|
HitPoints -= wear;
|
|
wear = 0;
|
|
}
|
|
else
|
|
{
|
|
wear -= HitPoints;
|
|
HitPoints = 0;
|
|
}
|
|
|
|
if ( wear > 0 )
|
|
{
|
|
if ( m_MaxHitPoints > wear )
|
|
{
|
|
MaxHitPoints -= wear;
|
|
|
|
if ( Parent is Mobile )
|
|
((Mobile)Parent).LocalOverheadMessage( MessageType.Regular, 0x3B2, 1061121 ); // Your equipment is severely damaged.
|
|
}
|
|
else
|
|
{
|
|
Delete();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return damageTaken;
|
|
}
|
|
|
|
private string GetNameString()
|
|
{
|
|
string name = this.Name;
|
|
|
|
if ( name == null )
|
|
name = String.Format( "#{0}", LabelNumber );
|
|
|
|
return name;
|
|
}
|
|
|
|
[Hue, CommandProperty( AccessLevel.GameMaster )]
|
|
public override int Hue
|
|
{
|
|
get{ return base.Hue; }
|
|
set{ base.Hue = value; InvalidateProperties(); }
|
|
}
|
|
|
|
public override bool AllowEquipedCast( Mobile from )
|
|
{
|
|
if ( base.AllowEquipedCast( from ) )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public override void GetProperties( ObjectPropertyList list )
|
|
{
|
|
base.GetProperties( list );
|
|
|
|
if ( m_Crafter != null )
|
|
list.Add( 1050043, m_Crafter.Name ); // crafted by ~1_NAME~
|
|
|
|
if ( m_Quality == ArmorQuality.Exceptional )
|
|
list.Add( 1060636 ); // exceptional
|
|
|
|
if ( m_StrBonus > 0 && m_StrBonus < 3 )
|
|
list.Add( 1038027 ); // Great Strength
|
|
else if ( m_StrBonus > 2 && m_StrBonus < 5 )
|
|
list.Add( 1038028 ); // Greater Strength
|
|
else if ( m_StrBonus > 4 )
|
|
list.Add( 1038029 ); // Ultimate Strength
|
|
|
|
if ( m_DexBonus > 0 && m_DexBonus < 3 )
|
|
list.Add( 1038033 ); // Great Agility
|
|
else if ( m_DexBonus > 2 && m_DexBonus < 5 )
|
|
list.Add( 1038034 ); // Greater Agility
|
|
else if ( m_DexBonus > 4 )
|
|
list.Add( 1038035 ); // Ultimate Agility
|
|
|
|
if ( m_IntBonus > 0 && m_IntBonus < 3 )
|
|
list.Add( 1038030 ); // Great Intellect
|
|
else if ( m_IntBonus > 2 && m_IntBonus < 5 )
|
|
list.Add( 1038031 ); // Greater Intellect
|
|
else if ( m_IntBonus > 4 )
|
|
list.Add( 1038032 ); // Ultimate Intellect
|
|
|
|
if ( m_Protection == ArmorProtectionLevel.Defense )
|
|
list.Add( 1036375 ); // Defensive Protection
|
|
else if ( m_Protection == ArmorProtectionLevel.Guarding )
|
|
list.Add( 1036376 ); // Guarded Protection
|
|
else if ( m_Protection == ArmorProtectionLevel.Hardening )
|
|
list.Add( 1036377 ); // Hardened Protection
|
|
else if ( m_Protection == ArmorProtectionLevel.Fortification )
|
|
list.Add( 1036378 ); // Fortified Protection
|
|
else if ( m_Protection == ArmorProtectionLevel.Invulnerability )
|
|
list.Add( 1036379 ); // Invulnerable Protection
|
|
|
|
if ( m_Durability == ArmorDurabilityLevel.Durable )
|
|
list.Add( 1036365 ); // Durable Material
|
|
else if ( m_Durability == ArmorDurabilityLevel.Substantial )
|
|
list.Add( 1036366 ); // Substantial Material
|
|
else if ( m_Durability == ArmorDurabilityLevel.Massive )
|
|
list.Add( 1036367 ); // Massive Material
|
|
else if ( m_Durability == ArmorDurabilityLevel.Fortified )
|
|
list.Add( 1036368 ); // Fortified Material
|
|
else if ( m_Durability == ArmorDurabilityLevel.Indestructible )
|
|
list.Add( 1036369 ); // Indestructible Material
|
|
|
|
if ( Server.Misc.Settings.DisplayInfo() )
|
|
{
|
|
int prop;
|
|
|
|
if ( (prop = (int)Math.Round(ArmorRatingScaled)) > 0 )
|
|
list.Add( 1060408, prop.ToString() ); // armor ~1_val~%
|
|
|
|
if ( (prop = GetDurabilityBonus()) > 0 )
|
|
list.Add( 1060410, prop.ToString() ); // durability ~1_val~%
|
|
|
|
if ( (prop = ComputeStatReq( StatType.Str )) > 0 )
|
|
list.Add( 1061170, prop.ToString() ); // strength requirement ~1_val~
|
|
|
|
if ( m_HitPoints >= 0 && m_MaxHitPoints > 0 )
|
|
list.Add( 1060639, "{0}\t{1}", m_HitPoints, m_MaxHitPoints ); // durability ~1_val~ / ~2_val~
|
|
}
|
|
else
|
|
{
|
|
double durable = (double)m_HitPoints / (double)m_MaxHitPoints;
|
|
|
|
if ( durable > 0.95 ){}
|
|
// DO NOT SHOW YET
|
|
else if ( durable > 0.75 )
|
|
list.Add( 1036374 ); // Perfect Condition
|
|
else if ( durable > 0.50 )
|
|
list.Add( 1036373 ); // Good Condition
|
|
else if ( durable > 0.25 )
|
|
list.Add( 1036372 ); // Fair Condition
|
|
else if ( durable > 0.05 )
|
|
list.Add( 1036371 ); // Poor Condition
|
|
else
|
|
list.Add( 1036370 ); // Horrible Condition
|
|
}
|
|
|
|
if ( Magical > 0 && Uses > 0 )
|
|
{
|
|
list.Add( 1062520, "\t#{0}", Magical );
|
|
}
|
|
|
|
if ( Uses > 0 && Server.Misc.Settings.DisplayInfo() )
|
|
{
|
|
if ( Uses > 1 )
|
|
list.Add( 1062516, "{0}", Uses );
|
|
else
|
|
list.Add( 1062517, "{0}", Uses );
|
|
}
|
|
else if ( Uses > 0 )
|
|
{
|
|
double usage = (double)Uses / (double)UsesMax;
|
|
|
|
if ( usage > 0.95 )
|
|
list.Add( 1063269 ); // Fully Charged
|
|
else if ( usage > 0.75 )
|
|
list.Add( 1063270 ); // Mostly Charged
|
|
else if ( usage > 0.50 )
|
|
list.Add( 1063271 ); // Partially Charged
|
|
else if ( usage > 0.25 )
|
|
list.Add( 1063272 ); // Somewhat Charged
|
|
else if ( usage > 0.05 )
|
|
list.Add( 1063273 ); // Barely Charged
|
|
else
|
|
list.Add( 1063274 ); // Almost Drained
|
|
}
|
|
}
|
|
|
|
#region ICraftable Members
|
|
|
|
public int OnCraft( int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, BaseTool tool, CraftItem craftItem, int resHue )
|
|
{
|
|
Quality = (ArmorQuality)quality;
|
|
|
|
if ( makersMark )
|
|
Crafter = from;
|
|
|
|
Type resourceType = typeRes;
|
|
|
|
if ( resourceType == null )
|
|
resourceType = craftItem.Resources.GetAt( 0 ).ItemType;
|
|
|
|
Resource = CraftResources.GetFromType( resourceType );
|
|
PlayerConstructed = true;
|
|
|
|
CraftContext context = craftSystem.GetContext( from );
|
|
|
|
if ( context != null && context.DoNotColor )
|
|
Hue = 0;
|
|
|
|
return quality;
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|