warrentyexpired/RunUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

#W# Source and Scripts added. Added Scripts/Settings.cs to expose some basic tweak able settings.

Browse source
This commit is contained in:
WarrentyExpired 2026-08-06 11:06:05 -04:00
parent b51c58f514
commit 3045c83799
3512 changed files with 627673 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

255
Scripts/Items/Containers/BaseTreasureChest.cs Normal file
View file

@ -0,0 +1,255 @@
using Server;
using Server.Items;
using Server.Network;
using System;
using System.Collections;
namespace Server.Items
{
public class BaseTreasureChest : LockableContainer
{
private TreasureLevel m_TreasureLevel;
private short m_MaxSpawnTime = 60;
private short m_MinSpawnTime = 10;
private TreasureResetTimer m_ResetTimer;
[CommandProperty( AccessLevel.GameMaster )]
public TreasureLevel Level
{
get
{
return m_TreasureLevel;
}
set
{
m_TreasureLevel = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public short MaxSpawnTime
{
get
{
return m_MaxSpawnTime;
}
set
{
m_MaxSpawnTime = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public short MinSpawnTime
{
get
{
return m_MinSpawnTime;
}
set
{
m_MinSpawnTime = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public override bool Locked {
get { return base.Locked; }
set {
if ( base.Locked != value ) {
base.Locked = value;
if ( !value )
StartResetTimer();
}
}
}
public override bool IsDecoContainer
{
get{ return false; }
}
public BaseTreasureChest( int itemID ) : this( itemID, TreasureLevel.Level2 )
{
}
public BaseTreasureChest( int itemID, TreasureLevel level ) : base( itemID )
{
m_TreasureLevel = level;
Locked = true;
Movable = false;
SetLockLevel();
GenerateTreasure();
}
public BaseTreasureChest( Serial serial ) : base( serial )
{
}
public override string DefaultName
{
get
{
if ( this.Locked )
return "a locked treasure chest";
return "a treasure chest";
}
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 0 );
writer.Write( (byte) m_TreasureLevel );
writer.Write( m_MinSpawnTime );
writer.Write( m_MaxSpawnTime );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
m_TreasureLevel = (TreasureLevel)reader.ReadByte();
m_MinSpawnTime = reader.ReadShort();
m_MaxSpawnTime = reader.ReadShort();
if( !Locked )
StartResetTimer();
}
protected virtual void SetLockLevel()
{
switch( m_TreasureLevel )
{
case TreasureLevel.Level1:
this.RequiredSkill = this.LockLevel = 5;
break;
case TreasureLevel.Level2:
this.RequiredSkill = this.LockLevel = 20;
break;
case TreasureLevel.Level3:
this.RequiredSkill = this.LockLevel = 50;
break;
case TreasureLevel.Level4:
this.RequiredSkill = this.LockLevel = 70;
break;
case TreasureLevel.Level5:
this.RequiredSkill = this.LockLevel = 90;
break;
case TreasureLevel.Level6:
this.RequiredSkill = this.LockLevel = 100;
break;
}
}
private void StartResetTimer()
{
if( m_ResetTimer == null )
m_ResetTimer = new TreasureResetTimer( this );
else
m_ResetTimer.Delay = TimeSpan.FromMinutes( Utility.Random( m_MinSpawnTime, m_MaxSpawnTime ));
m_ResetTimer.Start();
}
protected virtual void GenerateTreasure()
{
int MinGold = 1;
int MaxGold = 2;
switch( m_TreasureLevel )
{
case TreasureLevel.Level1:
MinGold = 100;
MaxGold = 300;
break;
case TreasureLevel.Level2:
MinGold = 300;
MaxGold = 600;
break;
case TreasureLevel.Level3:
MinGold = 600;
MaxGold = 900;
break;
case TreasureLevel.Level4:
MinGold = 900;
MaxGold = 1200;
break;
case TreasureLevel.Level5:
MinGold = 1200;
MaxGold = 5000;
break;
case TreasureLevel.Level6:
MinGold = 5000;
MaxGold = 9000;
break;
}
DropItem( new Gold( MinGold, MaxGold ) );
}
public void ClearContents()
{
for ( int i = Items.Count - 1; i >= 0; --i )
{
if ( i < Items.Count )
Items[i].Delete();
}
}
public void Reset()
{
if( m_ResetTimer != null )
{
if( m_ResetTimer.Running )
m_ResetTimer.Stop();
}
Locked = true;
ClearContents();
GenerateTreasure();
}
public enum TreasureLevel
{
Level1,
Level2,
Level3,
Level4,
Level5,
Level6,
};
private class TreasureResetTimer : Timer
{
private BaseTreasureChest m_Chest;
public TreasureResetTimer( BaseTreasureChest chest ) : base ( TimeSpan.FromMinutes( Utility.Random( chest.MinSpawnTime, chest.MaxSpawnTime ) ) )
{
m_Chest = chest;
Priority = TimerPriority.OneMinute;
}
protected override void OnTick()
{
m_Chest.Reset();
}
}
}
}

996
Scripts/Items/Containers/Container.cs Normal file
View file

@ -0,0 +1,996 @@
using System;
using System.Collections.Generic;
using Server.Multis;
using Server.Mobiles;
using Server.Network;
using Server.ContextMenus;
namespace Server.Items
{
public abstract class BaseContainer : Container
{
public override int DefaultMaxWeight
{
get
{
if ( IsSecure )
return 0;
return base.DefaultMaxWeight;
}
}
public BaseContainer( int itemID ) : base( itemID )
{
}
public override bool IsAccessibleTo( Mobile m )
{
if ( !BaseHouse.CheckAccessible( m, this ) )
return false;
return base.IsAccessibleTo( m );
}
public override bool CheckHold( Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight )
{
if ( this.IsSecure && !BaseHouse.CheckHold( m, this, item, message, checkItems, plusItems, plusWeight ) )
return false;
return base.CheckHold( m, item, message, checkItems, plusItems, plusWeight );
}
public override bool CheckItemUse( Mobile from, Item item )
{
if ( IsDecoContainer && item is BaseBook )
return true;
return base.CheckItemUse( from, item );
}
public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
{
base.GetContextMenuEntries( from, list );
SetSecureLevelEntry.AddTo( from, this, list );
}
public override bool TryDropItem( Mobile from, Item dropped, bool sendFullMessage )
{
if ( !CheckHold( from, dropped, sendFullMessage, true ) )
return false;
BaseHouse house = BaseHouse.FindHouseAt( this );
if ( house != null && house.IsLockedDown( this ) )
{
if ( dropped is VendorRentalContract || ( dropped is Container && ((Container)dropped).FindItemByType( typeof( VendorRentalContract ) ) != null ) )
{
from.SendLocalizedMessage( 1062492 ); // You cannot place a rental contract in a locked down container.
return false;
}
if ( !house.LockDown( from, dropped, false ) )
return false;
}
List<Item> list = this.Items;
for ( int i = 0; i < list.Count; ++i )
{
Item item = list[i];
if ( !(item is Container) && item.StackWith( from, dropped, false ) )
return true;
}
DropItem( dropped );
return true;
}
public override bool OnDragDropInto( Mobile from, Item item, Point3D p )
{
if ( !CheckHold( from, item, true, true ) )
return false;
BaseHouse house = BaseHouse.FindHouseAt( this );
if ( house != null && house.IsLockedDown( this ) )
{
if ( item is VendorRentalContract || ( item is Container && ((Container)item).FindItemByType( typeof( VendorRentalContract ) ) != null ) )
{
from.SendLocalizedMessage( 1062492 ); // You cannot place a rental contract in a locked down container.
return false;
}
if ( !house.LockDown( from, item, false ) )
return false;
}
item.Location = new Point3D( p.X, p.Y, 0 );
AddItem( item );
from.SendSound( GetDroppedSound( item ), GetWorldLocation() );
return true;
}
public override void UpdateTotal( Item sender, TotalType type, int delta )
{
base.UpdateTotal( sender, type, delta );
if ( type == TotalType.Weight && RootParent is Mobile )
((Mobile) RootParent).InvalidateProperties();
}
public override void OnDoubleClick( Mobile from )
{
if ( from.AccessLevel > AccessLevel.Player || from.InRange( this.GetWorldLocation(), 2 ) || this.RootParent is PlayerVendor )
Open( from );
else
from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
}
public virtual void Open( Mobile from )
{
DisplayTo( from );
}
public BaseContainer( Serial serial ) : base( serial )
{
}
/* Note: base class insertion; we cannot serialize anything here */
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
}
}
public class CreatureBackpack : Backpack //Used on BaseCreature
{
[Constructable]
public CreatureBackpack( string name )
{
Name = name;
Layer = Layer.Backpack;
Hue = 5;
Weight = 3.0;
}
public override void AddNameProperty( ObjectPropertyList list )
{
if ( Name != null )
list.Add( 1075257, Name ); // Contents of ~1_PETNAME~'s pack.
else
base.AddNameProperty( list );
}
public override void OnItemRemoved( Item item )
{
if ( Items.Count == 0 )
this.Delete();
base.OnItemRemoved( item );
}
public override bool OnDragLift( Mobile from )
{
if ( from.AccessLevel > AccessLevel.Player )
return true;
from.SendLocalizedMessage( 500169 ); // You cannot pick that up.
return false;
}
public override bool OnDragDropInto( Mobile from, Item item, Point3D p )
{
return false;
}
public override bool TryDropItem( Mobile from, Item dropped, bool sendFullMessage )
{
return false;
}
public CreatureBackpack( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 )
Weight = 13.0;
}
}
public class StrongBackpack : Backpack //Used on Pack animals
{
[Constructable]
public StrongBackpack()
{
Layer = Layer.Backpack;
Weight = 13.0;
}
public override bool CheckHold( Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight )
{
return base.CheckHold( m, item, false, checkItems, plusItems, plusWeight );
}
public override int DefaultMaxWeight{ get{ return 1600; } }
public override bool CheckContentDisplay( Mobile from )
{
object root = this.RootParent;
if ( root is BaseCreature && ((BaseCreature)root).Controlled && ((BaseCreature)root).ControlMaster == from )
return true;
return base.CheckContentDisplay( from );
}
public StrongBackpack( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 )
Weight = 13.0;
}
}
public class Backpack : BaseContainer, IDyable
{
[Constructable]
public Backpack() : base( 0xE75 )
{
Layer = Layer.Backpack;
Weight = 3.0;
}
public override int DefaultMaxWeight {
get {
if ( Core.ML ) {
Mobile m = Parent as Mobile;
if ( m != null && m.Player && m.Backpack == this ) {
return 550;
} else {
return base.DefaultMaxWeight;
}
} else {
return base.DefaultMaxWeight;
}
}
}
public Backpack( Serial serial ) : base( serial )
{
}
public bool Dye( Mobile from, DyeTub sender )
{
if ( Deleted ) return false;
Hue = sender.DyedHue;
return true;
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && ItemID == 0x9B2 )
ItemID = 0xE75;
}
}
public class Pouch : TrapableContainer
{
[Constructable]
public Pouch() : base( 0xE79 )
{
Weight = 1.0;
}
public Pouch( Serial serial ) : base( serial )
{
}
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 abstract class BaseBagBall : BaseContainer, IDyable
{
public BaseBagBall( int itemID ) : base( itemID )
{
Weight = 1.0;
}
public BaseBagBall( Serial serial ) : base( serial )
{
}
public bool Dye( Mobile from, DyeTub sender )
{
if ( Deleted )
return false;
Hue = sender.DyedHue;
return true;
}
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 SmallBagBall : BaseBagBall
{
[Constructable]
public SmallBagBall() : base( 0x2256 )
{
}
public SmallBagBall( Serial serial ) : base( serial )
{
}
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 LargeBagBall : BaseBagBall
{
[Constructable]
public LargeBagBall() : base( 0x2257 )
{
}
public LargeBagBall( Serial serial ) : base( serial )
{
}
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 Bag : BaseContainer, IDyable
{
[Constructable]
public Bag() : base( 0xE76 )
{
Weight = 2.0;
}
public Bag( Serial serial ) : base( serial )
{
}
public bool Dye( Mobile from, DyeTub sender )
{
if ( Deleted ) return false;
Hue = sender.DyedHue;
return true;
}
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 Barrel : BaseContainer
{
[Constructable]
public Barrel() : base( 0xE77 )
{
Weight = 25.0;
}
public Barrel( Serial serial ) : base( serial )
{
}
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();
if ( Weight == 0.0 )
Weight = 25.0;
}
}
public class Keg : BaseContainer
{
[Constructable]
public Keg() : base( 0xE7F )
{
Weight = 15.0;
}
public Keg( Serial serial ) : base( serial )
{
}
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 PicnicBasket : BaseContainer
{
[Constructable]
public PicnicBasket() : base( 0xE7A )
{
Weight = 2.0; // Stratics doesn't know weight
}
public PicnicBasket( Serial serial ) : base( serial )
{
}
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 Basket : BaseContainer
{
[Constructable]
public Basket() : base( 0x990 )
{
Weight = 1.0; // Stratics doesn't know weight
}
public Basket( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x9AA, 0xE7D )]
public class WoodenBox : LockableContainer
{
[Constructable]
public WoodenBox() : base( 0x9AA )
{
Weight = 4.0;
}
public WoodenBox( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x9A9, 0xE7E )]
public class SmallCrate : LockableContainer
{
[Constructable]
public SmallCrate() : base( 0x9A9 )
{
Weight = 2.0;
}
public SmallCrate( Serial serial ) : base( serial )
{
}
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();
if ( Weight == 4.0 )
Weight = 2.0;
}
}
[Furniture]
[Flipable( 0xE3F, 0xE3E )]
public class MediumCrate : LockableContainer
{
[Constructable]
public MediumCrate() : base( 0xE3F )
{
Weight = 2.0;
}
public MediumCrate( Serial serial ) : base( serial )
{
}
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();
if ( Weight == 6.0 )
Weight = 2.0;
}
}
[Furniture]
[Flipable( 0xE3D, 0xE3C )]
public class LargeCrate : LockableContainer
{
[Constructable]
public LargeCrate() : base( 0xE3D )
{
Weight = 1.0;
}
public LargeCrate( Serial serial ) : base( serial )
{
}
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();
if ( Weight == 8.0 )
Weight = 1.0;
}
}
[DynamicFliping]
[Flipable( 0x9A8, 0xE80 )]
public class MetalBox : LockableContainer
{
[Constructable]
public MetalBox() : base( 0x9A8 )
{
}
public MetalBox( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 3 )
Weight = -1;
}
}
[DynamicFliping]
[Flipable( 0x9AB, 0xE7C )]
public class MetalChest : LockableContainer
{
[Constructable]
public MetalChest() : base( 0x9AB )
{
}
public MetalChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 25 )
Weight = -1;
}
}
[DynamicFliping]
[Flipable( 0xE41, 0xE40 )]
public class MetalGoldenChest : LockableContainer
{
[Constructable]
public MetalGoldenChest() : base( 0xE41 )
{
}
public MetalGoldenChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 25 )
Weight = -1;
}
}
[Furniture]
[Flipable( 0xe43, 0xe42 )]
public class WoodenChest : LockableContainer
{
[Constructable]
public WoodenChest() : base( 0xe43 )
{
Weight = 2.0;
}
public WoodenChest( Serial serial ) : base( serial )
{
}
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();
if ( Weight == 15.0 )
Weight = 2.0;
}
}
[Furniture]
[Flipable( 0x280B, 0x280C )]
public class PlainWoodenChest : LockableContainer
{
[Constructable]
public PlainWoodenChest() : base( 0x280B )
{
}
public PlainWoodenChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 15 )
Weight = -1;
}
}
[Furniture]
[Flipable( 0x280D, 0x280E )]
public class OrnateWoodenChest : LockableContainer
{
[Constructable]
public OrnateWoodenChest() : base( 0x280D )
{
}
public OrnateWoodenChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 15 )
Weight = -1;
}
}
[Furniture]
[Flipable( 0x280F, 0x2810 )]
public class GildedWoodenChest : LockableContainer
{
[Constructable]
public GildedWoodenChest() : base( 0x280F )
{
}
public GildedWoodenChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 15 )
Weight = -1;
}
}
[Furniture]
[Flipable( 0x2811, 0x2812 )]
public class WoodenFootLocker : LockableContainer
{
[Constructable]
public WoodenFootLocker() : base( 0x2811 )
{
GumpID = 0x10B;
}
public WoodenFootLocker( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 2 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 15 )
Weight = -1;
if ( version < 2 )
GumpID = 0x10B;
}
}
[Furniture]
[Flipable( 0x2813, 0x2814 )]
public class FinishedWoodenChest : LockableContainer
{
[Constructable]
public FinishedWoodenChest() : base( 0x2813 )
{
}
public FinishedWoodenChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 15 )
Weight = -1;
}
}
}

1529
Scripts/Items/Containers/FillableContainers.cs Normal file
View file

File diff suppressed because it is too large Load diff

430
Scripts/Items/Containers/FurnitureContainer.cs Normal file
View file

@ -0,0 +1,430 @@
using System;
using System.Collections.Generic;
using Server;
using Server.Multis;
using Server.Network;
namespace Server.Items
{
[Furniture]
[Flipable( 0x2815, 0x2816 )]
public class TallCabinet : BaseContainer
{
[Constructable]
public TallCabinet() : base( 0x2815 )
{
Weight = 1.0;
}
public TallCabinet( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x2817, 0x2818 )]
public class ShortCabinet : BaseContainer
{
[Constructable]
public ShortCabinet() : base( 0x2817 )
{
Weight = 1.0;
}
public ShortCabinet( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x2857, 0x2858 )]
public class RedArmoire : BaseContainer
{
[Constructable]
public RedArmoire() : base( 0x2857 )
{
Weight = 1.0;
}
public RedArmoire( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x285D, 0x285E )]
public class CherryArmoire : BaseContainer
{
[Constructable]
public CherryArmoire() : base( 0x285D )
{
Weight = 1.0;
}
public CherryArmoire( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x285B, 0x285C )]
public class MapleArmoire : BaseContainer
{
[Constructable]
public MapleArmoire() : base( 0x285B )
{
Weight = 1.0;
}
public MapleArmoire( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0x2859, 0x285A )]
public class ElegantArmoire : BaseContainer
{
[Constructable]
public ElegantArmoire() : base( 0x2859 )
{
Weight = 1.0;
}
public ElegantArmoire( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0xa97, 0xa99, 0xa98, 0xa9a, 0xa9b, 0xa9c )]
public class FullBookcase : BaseContainer
{
[Constructable]
public FullBookcase() : base( 0xA97 )
{
Weight = 1.0;
}
public FullBookcase( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0xa9d, 0xa9e )]
public class EmptyBookcase : BaseContainer
{
[Constructable]
public EmptyBookcase() : base( 0xA9D )
{
}
public EmptyBookcase( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 1 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
if ( version == 0 && Weight == 1.0 )
Weight = -1;
}
}
[Furniture]
[Flipable( 0xa2c, 0xa34 )]
public class Drawer : BaseContainer
{
[Constructable]
public Drawer() : base( 0xA2C )
{
Weight = 1.0;
}
public Drawer( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0xa30, 0xa38 )]
public class FancyDrawer : BaseContainer
{
[Constructable]
public FancyDrawer() : base( 0xA30 )
{
Weight = 1.0;
}
public FancyDrawer( Serial serial ) : base( serial )
{
}
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();
}
}
[Furniture]
[Flipable( 0xa4f, 0xa53 )]
public class Armoire : BaseContainer
{
[Constructable]
public Armoire() : base( 0xA4F )
{
Weight = 1.0;
}
public override void DisplayTo( Mobile m )
{
if ( DynamicFurniture.Open( this, m ) )
base.DisplayTo( m );
}
public Armoire( Serial serial ) : base( serial )
{
}
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();
DynamicFurniture.Close( this );
}
}
[Furniture]
[Flipable( 0xa4d, 0xa51 )]
public class FancyArmoire : BaseContainer
{
[Constructable]
public FancyArmoire() : base( 0xA4D )
{
Weight = 1.0;
}
public override void DisplayTo( Mobile m )
{
if ( DynamicFurniture.Open( this, m ) )
base.DisplayTo( m );
}
public FancyArmoire( Serial serial ) : base( serial )
{
}
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();
DynamicFurniture.Close( this );
}
}
public class DynamicFurniture
{
private static Dictionary<Container, Timer> m_Table = new Dictionary<Container, Timer>();
public static bool Open( Container c, Mobile m )
{
if ( m_Table.ContainsKey( c ) )
{
c.SendRemovePacket();
Close( c );
c.Delta( ItemDelta.Update );
c.ProcessDelta();
return false;
}
if ( c is Armoire || c is FancyArmoire )
{
Timer t = new FurnitureTimer( c, m );
t.Start();
m_Table[c] = t;
switch ( c.ItemID )
{
case 0xA4D: c.ItemID = 0xA4C; break;
case 0xA4F: c.ItemID = 0xA4E; break;
case 0xA51: c.ItemID = 0xA50; break;
case 0xA53: c.ItemID = 0xA52; break;
}
}
return true;
}
public static void Close( Container c )
{
Timer t = null;
m_Table.TryGetValue( c, out t );
if ( t != null )
{
t.Stop();
m_Table.Remove( c );
}
if ( c is Armoire || c is FancyArmoire )
{
switch ( c.ItemID )
{
case 0xA4C: c.ItemID = 0xA4D; break;
case 0xA4E: c.ItemID = 0xA4F; break;
case 0xA50: c.ItemID = 0xA51; break;
case 0xA52: c.ItemID = 0xA53; break;
}
}
}
}
public class FurnitureTimer : Timer
{
private Container m_Container;
private Mobile m_Mobile;
public FurnitureTimer( Container c, Mobile m ) : base( TimeSpan.FromSeconds( 0.5 ), TimeSpan.FromSeconds( 0.5 ) )
{
Priority = TimerPriority.TwoFiftyMS;
m_Container = c;
m_Mobile = m;
}
protected override void OnTick()
{
if ( m_Mobile.Map != m_Container.Map || !m_Mobile.InRange( m_Container.GetWorldLocation(), 3 ) )
DynamicFurniture.Close( m_Container );
}
}
}

413
Scripts/Items/Containers/LockableContainer.cs Normal file
View file

@ -0,0 +1,413 @@
using System;
using Server.Network;
using Server.Items;
using Server.Engines.Craft;
namespace Server.Items
{
public abstract class LockableContainer : TrapableContainer, ILockable, ILockpickable, ICraftable, IShipwreckedItem
{
private bool m_Locked;
private int m_LockLevel, m_MaxLockLevel, m_RequiredSkill;
private uint m_KeyValue;
private Mobile m_Picker;
private bool m_TrapOnLockpick;
[CommandProperty( AccessLevel.GameMaster )]
public Mobile Picker
{
get
{
return m_Picker;
}
set
{
m_Picker = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public int MaxLockLevel
{
get
{
return m_MaxLockLevel;
}
set
{
m_MaxLockLevel = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public int LockLevel
{
get
{
return m_LockLevel;
}
set
{
m_LockLevel = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public int RequiredSkill
{
get
{
return m_RequiredSkill;
}
set
{
m_RequiredSkill = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public virtual bool Locked
{
get
{
return m_Locked;
}
set
{
m_Locked = value;
if ( m_Locked )
m_Picker = null;
InvalidateProperties();
}
}
[CommandProperty( AccessLevel.GameMaster )]
public uint KeyValue
{
get
{
return m_KeyValue;
}
set
{
m_KeyValue = value;
}
}
public override bool TrapOnOpen
{
get
{
return !m_TrapOnLockpick;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public bool TrapOnLockpick
{
get
{
return m_TrapOnLockpick;
}
set
{
m_TrapOnLockpick = value;
}
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 6 ); // version
writer.Write( m_IsShipwreckedItem );
writer.Write( (bool) m_TrapOnLockpick );
writer.Write( (int) m_RequiredSkill );
writer.Write( (int) m_MaxLockLevel );
writer.Write( m_KeyValue );
writer.Write( (int) m_LockLevel );
writer.Write( (bool) m_Locked );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 6:
{
m_IsShipwreckedItem = reader.ReadBool();
goto case 5;
}
case 5:
{
m_TrapOnLockpick = reader.ReadBool();
goto case 4;
}
case 4:
{
m_RequiredSkill = reader.ReadInt();
goto case 3;
}
case 3:
{
m_MaxLockLevel = reader.ReadInt();
goto case 2;
}
case 2:
{
m_KeyValue = reader.ReadUInt();
goto case 1;
}
case 1:
{
m_LockLevel = reader.ReadInt();
goto case 0;
}
case 0:
{
if ( version < 3 )
m_MaxLockLevel = 100;
if ( version < 4 )
{
if ( (m_MaxLockLevel - m_LockLevel) == 40 )
{
m_RequiredSkill = m_LockLevel + 6;
m_LockLevel = m_RequiredSkill - 10;
m_MaxLockLevel = m_RequiredSkill + 39;
}
else
{
m_RequiredSkill = m_LockLevel;
}
}
m_Locked = reader.ReadBool();
break;
}
}
}
public LockableContainer( int itemID ) : base( itemID )
{
m_MaxLockLevel = 100;
}
public LockableContainer( Serial serial ) : base( serial )
{
}
public override bool CheckContentDisplay( Mobile from )
{
return !m_Locked && base.CheckContentDisplay( from );
}
public override bool TryDropItem( Mobile from, Item dropped, bool sendFullMessage )
{
if ( from.AccessLevel < AccessLevel.GameMaster && m_Locked )
{
from.SendLocalizedMessage( 501747 ); // It appears to be locked.
return false;
}
return base.TryDropItem( from, dropped, sendFullMessage );
}
public override bool OnDragDropInto( Mobile from, Item item, Point3D p )
{
if ( from.AccessLevel < AccessLevel.GameMaster && m_Locked )
{
from.SendLocalizedMessage( 501747 ); // It appears to be locked.
return false;
}
return base.OnDragDropInto( from, item, p );
}
public override bool CheckLift( Mobile from, Item item, ref LRReason reject )
{
if ( !base.CheckLift( from, item, ref reject ) )
return false;
if ( item != this && from.AccessLevel < AccessLevel.GameMaster && m_Locked )
return false;
return true;
}
public override bool CheckItemUse( Mobile from, Item item )
{
if ( !base.CheckItemUse( from, item ) )
return false;
if ( item != this && from.AccessLevel < AccessLevel.GameMaster && m_Locked )
{
from.LocalOverheadMessage( MessageType.Regular, 0x3B2, 1019045 ); // I can't reach that.
return false;
}
return true;
}
public override bool DisplaysContent{ get{ return !m_Locked; } }
public virtual bool CheckLocked( Mobile from )
{
bool inaccessible = false;
if ( m_Locked )
{
int number;
if ( from.AccessLevel >= AccessLevel.GameMaster )
{
number = 502502; // That is locked, but you open it with your godly powers.
}
else
{
number = 501747; // It appears to be locked.
inaccessible = true;
}
from.Send( new MessageLocalized( Serial, ItemID, MessageType.Regular, 0x3B2, 3, number, "", "" ) );
}
return inaccessible;
}
public override void OnTelekinesis( Mobile from )
{
if ( CheckLocked( from ) )
{
Effects.SendLocationParticles( EffectItem.Create( Location, Map, EffectItem.DefaultDuration ), 0x376A, 9, 32, 5022 );
Effects.PlaySound( Location, Map, 0x1F5 );
return;
}
base.OnTelekinesis( from );
}
public override void OnDoubleClickSecureTrade( Mobile from )
{
if ( CheckLocked( from ) )
return;
base.OnDoubleClickSecureTrade( from );
}
public override void Open( Mobile from )
{
if ( CheckLocked( from ) )
return;
base.Open( from );
}
public override void OnSnoop( Mobile from )
{
if ( CheckLocked( from ) )
return;
base.OnSnoop( from );
}
public virtual void LockPick( Mobile from )
{
Locked = false;
Picker = from;
if ( this.TrapOnLockpick && ExecuteTrap( from ) )
{
this.TrapOnLockpick = false;
}
}
public override void AddNameProperties( ObjectPropertyList list )
{
base.AddNameProperties( list );
if ( m_IsShipwreckedItem )
list.Add( 1041645 ); // recovered from a shipwreck
}
public override void OnSingleClick( Mobile from )
{
base.OnSingleClick( from );
if ( m_IsShipwreckedItem )
LabelTo( from, 1041645 ); //recovered from a shipwreck
}
#region ICraftable Members
public int OnCraft( int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, BaseTool tool, CraftItem craftItem, int resHue )
{
if ( from.CheckSkill( SkillName.Tinkering, -5.0, 15.0 ) )
{
from.SendLocalizedMessage( 500636 ); // Your tinker skill was sufficient to make the item lockable.
Key key = new Key( KeyType.Copper, Key.RandomValue() );
KeyValue = key.KeyValue;
DropItem( key );
double tinkering = from.Skills[SkillName.Tinkering].Value;
int level = (int)(tinkering * 0.8);
RequiredSkill = level - 4;
LockLevel = level - 14;
MaxLockLevel = level + 35;
if ( LockLevel == 0 )
LockLevel = -1;
else if ( LockLevel > 95 )
LockLevel = 95;
if ( RequiredSkill > 95 )
RequiredSkill = 95;
if ( MaxLockLevel > 95 )
MaxLockLevel = 95;
}
else
{
from.SendLocalizedMessage( 500637 ); // Your tinker skill was insufficient to make the item lockable.
}
return 1;
}
#endregion
#region IShipwreckedItem Members
private bool m_IsShipwreckedItem;
[CommandProperty( AccessLevel.GameMaster )]
public bool IsShipwreckedItem
{
get { return m_IsShipwreckedItem; }
set { m_IsShipwreckedItem = value; }
}
#endregion
}
}

267
Scripts/Items/Containers/MarkContainer.cs Normal file
View file

@ -0,0 +1,267 @@
using System;
using Server;
using Server.Commands;
namespace Server.Items
{
public class MarkContainer : LockableContainer
{
public static void Initialize()
{
CommandSystem.Register( "SecretLocGen", AccessLevel.Administrator, new CommandEventHandler( SecretLocGen_OnCommand ) );
}
[Usage( "SecretLocGen" )]
[Description( "Generates mark containers to Malas secret locations." )]
public static void SecretLocGen_OnCommand( CommandEventArgs e )
{
CreateMalasPassage( 951, 546, -70, 1006, 994, -70, false, false );
CreateMalasPassage( 914, 192, -79, 1019, 1062, -70, false, false );
CreateMalasPassage( 1614, 143, -90, 1214, 1313, -90, false, false );
CreateMalasPassage( 2176, 324, -90, 1554, 172, -90, false, false );
CreateMalasPassage( 864, 812, -90, 1061, 1161, -70, false, false );
CreateMalasPassage( 1051, 1434, -85, 1076, 1244, -70, false, true );
CreateMalasPassage( 1326, 523, -87, 1201, 1554, -70, false, false );
CreateMalasPassage( 424, 189, -1, 2333, 1501, -90, true, false );
CreateMalasPassage( 1313, 1115, -85, 1183, 462, -45, false, false );
e.Mobile.SendMessage( "Secret mark containers have been created." );
}
private static bool FindMarkContainer( Point3D p, Map map )
{
IPooledEnumerable eable = map.GetItemsInRange( p, 0 );
foreach ( Item item in eable )
{
if ( item.Z == p.Z && item is MarkContainer )
{
eable.Free();
return true;
}
}
eable.Free();
return false;
}
private static void CreateMalasPassage( int x, int y, int z, int xTarget, int yTarget, int zTarget, bool bone, bool locked )
{
Point3D location = new Point3D( x, y, z );
if ( FindMarkContainer( location, Map.Malas ) )
return;
MarkContainer cont = new MarkContainer( bone, locked );
cont.TargetMap = Map.Malas;
cont.Target = new Point3D( xTarget, yTarget, zTarget );
cont.Description = "strange location";
cont.MoveToWorld( location, Map.Malas );
}
private bool m_AutoLock;
private InternalTimer m_RelockTimer;
private Map m_TargetMap;
private Point3D m_Target;
private string m_Description;
[CommandProperty( AccessLevel.GameMaster )]
public bool AutoLock
{
get { return m_AutoLock; }
set
{
m_AutoLock = value;
if ( !m_AutoLock )
StopTimer();
else if ( !Locked && m_RelockTimer == null )
m_RelockTimer = new InternalTimer( this );
}
}
[CommandProperty( AccessLevel.GameMaster )]
public Map TargetMap { get { return m_TargetMap; } set { m_TargetMap = value; } }
[CommandProperty( AccessLevel.GameMaster )]
public Point3D Target { get { return m_Target; } set { m_Target = value; } }
[CommandProperty( AccessLevel.GameMaster )]
public bool Bone
{
get { return ItemID == 0xECA; }
set
{
ItemID = value ? 0xECA : 0xE79;
Hue = value ? 1102 : 0;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public string Description { get { return m_Description; } set { m_Description = value; } }
public override bool IsDecoContainer
{
get{ return false; }
}
[Constructable]
public MarkContainer() : this( false )
{
}
[Constructable]
public MarkContainer( bool bone ) : this( bone, false )
{
}
[Constructable]
public MarkContainer( bool bone, bool locked ) : base( bone ? 0xECA : 0xE79 )
{
Movable = false;
if ( bone )
Hue = 1102;
m_AutoLock = locked;
Locked = locked;
if ( locked )
LockLevel = -255;
}
public MarkContainer( Serial serial ) : base( serial )
{
}
[CommandProperty( AccessLevel.GameMaster )]
public override bool Locked
{
get { return base.Locked; }
set
{
base.Locked = value;
if ( m_AutoLock )
{
StopTimer();
if ( !Locked )
m_RelockTimer = new InternalTimer( this );
}
}
}
public void StopTimer()
{
if ( m_RelockTimer != null )
m_RelockTimer.Stop();
m_RelockTimer = null;
}
private class InternalTimer : Timer
{
private MarkContainer m_Container;
private DateTime m_RelockTime;
public MarkContainer Container { get { return m_Container; } }
public DateTime RelockTime { get { return m_RelockTime; } }
public InternalTimer( MarkContainer container ) : this( container, TimeSpan.FromMinutes( 5.0 ) )
{
}
public InternalTimer( MarkContainer container, TimeSpan delay ) : base( delay )
{
m_Container = container;
m_RelockTime = DateTime.UtcNow + delay;
Start();
}
protected override void OnTick()
{
m_Container.Locked = true;
m_Container.LockLevel = -255;
}
}
public void Mark( RecallRune rune )
{
if ( TargetMap != null )
{
rune.Marked = true;
rune.TargetMap = m_TargetMap;
rune.Target = m_Target;
rune.Description = m_Description;
rune.House = null;
}
}
public override bool OnDragDrop( Mobile from, Item dropped )
{
RecallRune rune = dropped as RecallRune;
if ( rune != null && base.OnDragDrop( from, dropped ) )
{
Mark( rune );
return true;
}
else
{
return false;
}
}
public override bool OnDragDropInto( Mobile from, Item dropped, Point3D p )
{
RecallRune rune = dropped as RecallRune;
if ( rune != null && base.OnDragDropInto( from, dropped, p ) )
{
Mark( rune );
return true;
}
else
{
return false;
}
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int)0 ); // version
writer.Write( m_AutoLock );
if ( !Locked && m_AutoLock )
writer.WriteDeltaTime( m_RelockTimer.RelockTime );
writer.Write( m_TargetMap );
writer.Write( m_Target );
writer.Write( m_Description );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
m_AutoLock = reader.ReadBool();
if ( !Locked && m_AutoLock )
m_RelockTimer = new InternalTimer( this, reader.ReadDeltaTime() - DateTime.UtcNow );
m_TargetMap = reader.ReadMap();
m_Target = reader.ReadPoint3D();
m_Description = reader.ReadString();
}
}
}

235
Scripts/Items/Containers/ParagonChest.cs Normal file
View file

@ -0,0 +1,235 @@
using System;
using System.Collections;
using Server;
using Server.Gumps;
using Server.Multis;
using Server.Network;
using Server.ContextMenus;
using Server.Engines.PartySystem;
namespace Server.Items
{
[Flipable]
public class ParagonChest : LockableContainer
{
private static int[] m_ItemIDs = new int[]
{
0x9AB, 0xE40, 0xE41, 0xE7C
};
private static int[] m_Hues = new int[]
{
0x0, 0x455, 0x47E, 0x89F, 0x8A5, 0x8AB,
0x966, 0x96D, 0x972, 0x973, 0x979
};
private string m_Name;
[Constructable]
public ParagonChest( string name, int level ) : base( Utility.RandomList( m_ItemIDs ) )
{
m_Name = name;
Hue = Utility.RandomList( m_Hues );
Fill( level );
}
public override void OnSingleClick( Mobile from )
{
base.OnSingleClick(from);
LabelTo( from, 1063449, m_Name );
}
public override void GetProperties( ObjectPropertyList list )
{
base.GetProperties( list );
list.Add( 1063449, m_Name );
}
private static void GetRandomAOSStats( out int attributeCount, out int min, out int max )
{
int rnd = Utility.Random( 15 );
if ( rnd < 1 )
{
attributeCount = Utility.RandomMinMax( 2, 6 );
min = 20; max = 70;
}
else if ( rnd < 3 )
{
attributeCount = Utility.RandomMinMax( 2, 4 );
min = 20; max = 50;
}
else if ( rnd < 6 )
{
attributeCount = Utility.RandomMinMax( 2, 3 );
min = 20; max = 40;
}
else if ( rnd < 10 )
{
attributeCount = Utility.RandomMinMax( 1, 2 );
min = 10; max = 30;
}
else
{
attributeCount = 1;
min = 10; max = 20;
}
}
public void Flip()
{
switch ( ItemID )
{
case 0x9AB : ItemID = 0xE7C; break;
case 0xE7C : ItemID = 0x9AB; break;
case 0xE40 : ItemID = 0xE41; break;
case 0xE41 : ItemID = 0xE40; break;
}
}
private void Fill( int level )
{
TrapType = TrapType.ExplosionTrap;
TrapPower = level * 25;
TrapLevel = level;
Locked = true;
switch ( level )
{
case 1: RequiredSkill = 36; break;
case 2: RequiredSkill = 76; break;
case 3: RequiredSkill = 84; break;
case 4: RequiredSkill = 92; break;
case 5: RequiredSkill = 100; break;
}
LockLevel = RequiredSkill - 10;
MaxLockLevel = RequiredSkill + 40;
DropItem( new Gold( level * 200 ) );
for ( int i = 0; i < level; ++i )
DropItem( Loot.RandomScroll( 0, 63, SpellbookType.Regular ) );
for ( int i = 0; i < level * 2; ++i )
{
Item item;
if ( Core.AOS )
item = Loot.RandomArmorOrShieldOrWeaponOrJewelry();
else
item = Loot.RandomArmorOrShieldOrWeapon();
if ( item is BaseWeapon )
{
BaseWeapon weapon = (BaseWeapon)item;
if ( Core.AOS )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( weapon, attributeCount, min, max );
}
else
{
weapon.DamageLevel = (WeaponDamageLevel)Utility.Random( 6 );
weapon.AccuracyLevel = (WeaponAccuracyLevel)Utility.Random( 6 );
weapon.DurabilityLevel = (WeaponDurabilityLevel)Utility.Random( 6 );
}
DropItem( item );
}
else if ( item is BaseArmor )
{
BaseArmor armor = (BaseArmor)item;
if ( Core.AOS )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( armor, attributeCount, min, max );
}
else
{
armor.ProtectionLevel = (ArmorProtectionLevel)Utility.Random( 6 );
armor.Durability = (ArmorDurabilityLevel)Utility.Random( 6 );
}
DropItem( item );
}
else if( item is BaseHat )
{
BaseHat hat = (BaseHat)item;
if( Core.AOS )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( hat, attributeCount, min, max );
}
DropItem( item );
}
else if( item is BaseJewel )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( (BaseJewel)item, attributeCount, min, max );
DropItem( item );
}
}
for ( int i = 0; i < level; i++ )
{
Item item = Loot.RandomPossibleReagent();
item.Amount = Utility.RandomMinMax( 40, 60 );
DropItem( item );
}
for ( int i = 0; i < level; i++ )
{
Item item = Loot.RandomGem();
DropItem( item );
}
DropItem( new TreasureMap( level + 1, ( Utility.RandomBool() ? Map.Felucca : Map.Trammel ) ) );
}
public ParagonChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 0 ); // version
writer.Write( m_Name );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
m_Name = Utility.Intern( reader.ReadString() );
}
}
}

391
Scripts/Items/Containers/SalvageBag.cs Normal file
View file

@ -0,0 +1,391 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Server.ContextMenus;
using Server.Engines.Craft;
using Server.Network;
using Server.Targeting;
namespace Server.Items
{
public class SalvageBag : Bag
{
private bool m_Failure;
public override int LabelNumber { get { return 1079931; } } // Salvage Bag
[Constructable]
public SalvageBag()
: this( Utility.RandomBlueHue() )
{
}
[Constructable]
public SalvageBag( int hue )
{
Weight = 2.0;
Hue = hue;
m_Failure = false;
}
public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
{
base.GetContextMenuEntries( from, list );
if( from.Alive )
{
list.Add( new SalvageIngotsEntry( this, IsChildOf( from.Backpack ) && Resmeltables() ) );
list.Add( new SalvageClothEntry( this, IsChildOf( from.Backpack ) && Scissorables() ) );
list.Add( new SalvageAllEntry( this, IsChildOf( from.Backpack ) && Resmeltables() && Scissorables() ) );
}
}
#region Checks
private bool Resmeltables() //Where context menu checks for metal items and dragon barding deeds
{
foreach( Item i in Items )
{
if( i != null && !i.Deleted )
{
if( i is BaseWeapon )
{
if( CraftResources.GetType( ( (BaseWeapon)i ).Resource ) == CraftResourceType.Metal )
return true;
}
if( i is BaseArmor )
{
if( CraftResources.GetType( ( (BaseArmor)i ).Resource ) == CraftResourceType.Metal )
return true;
}
if( i is DragonBardingDeed )
return true;
}
}
return false;
}
private bool Scissorables() //Where context menu checks for Leather items and cloth items
{
foreach( Item i in Items )
{
if( i != null && !i.Deleted )
{
if( i is IScissorable )
{
if( i is BaseClothing )
return true;
if( i is BaseArmor )
{
if( CraftResources.GetType( ( (BaseArmor)i ).Resource ) == CraftResourceType.Leather )
return true;
}
if( ( i is Cloth ) || ( i is BoltOfCloth ) || ( i is Hides ) || ( i is BonePile ) )
return true;
}
}
}
return false;
}
#endregion
#region Resmelt.cs
private bool Resmelt( Mobile from, Item item, CraftResource resource )
{
try
{
if( CraftResources.GetType( resource ) != CraftResourceType.Metal )
return false;
CraftResourceInfo info = CraftResources.GetInfo( resource );
if( info == null || info.ResourceTypes.Length == 0 )
return false;
CraftItem craftItem = DefBlacksmithy.CraftSystem.CraftItems.SearchFor( item.GetType() );
if( craftItem == null || craftItem.Resources.Count == 0 )
return false;
CraftRes craftResource = craftItem.Resources.GetAt( 0 );
if( craftResource.Amount < 2 )
return false; // Not enough metal to resmelt
double difficulty = 0.0;
switch ( resource )
{
case CraftResource.DullCopper: difficulty = 65.0; break;
case CraftResource.ShadowIron: difficulty = 70.0; break;
case CraftResource.Copper: difficulty = 75.0; break;
case CraftResource.Bronze: difficulty = 80.0; break;
case CraftResource.Gold: difficulty = 85.0; break;
case CraftResource.Agapite: difficulty = 90.0; break;
case CraftResource.Verite: difficulty = 95.0; break;
case CraftResource.Valorite: difficulty = 99.0; break;
}
Type resourceType = info.ResourceTypes[ 0 ];
Item ingot = (Item)Activator.CreateInstance( resourceType );
if( item is DragonBardingDeed || ( item is BaseArmor && ( (BaseArmor)item ).PlayerConstructed ) || ( item is BaseWeapon && ( (BaseWeapon)item ).PlayerConstructed ) || ( item is BaseClothing && ( (BaseClothing)item ).PlayerConstructed ) )
{
double mining = from.Skills[ SkillName.Mining ].Value;
if( mining > 100.0 )
mining = 100.0;
double amount = ( ( ( 4 + mining ) * craftResource.Amount - 4 ) * 0.0068 );
if( amount < 2 )
ingot.Amount = 2;
else
ingot.Amount = (int)amount;
}
else
{
ingot.Amount = 2;
}
if ( difficulty > from.Skills[ SkillName.Mining ].Value )
{
m_Failure = true;
ingot.Delete();
}
else
item.Delete();
from.AddToBackpack( ingot );
from.PlaySound( 0x2A );
from.PlaySound( 0x240 );
return true;
}
catch( Exception ex )
{
Console.WriteLine( ex.ToString() );
}
return false;
}
#endregion
#region Salvaging
private void SalvageIngots( Mobile from )
{
Item[] tools = from.Backpack.FindItemsByType( typeof( BaseTool ) );
bool ToolFound = false;
foreach( Item tool in tools )
{
if( tool is BaseTool && ( (BaseTool)tool ).CraftSystem == DefBlacksmithy.CraftSystem )
ToolFound = true;
}
if( !ToolFound )
{
from.SendLocalizedMessage( 1079822 ); // You need a blacksmithing tool in order to salvage ingots.
return;
}
bool anvil, forge;
DefBlacksmithy.CheckAnvilAndForge( from, 2, out anvil, out forge );
if( !forge )
{
from.SendLocalizedMessage( 1044265 ); // You must be near a forge.
return;
}
int salvaged = 0;
int notSalvaged = 0;
Container sBag = this;
List<Item> Smeltables = sBag.FindItemsByType<Item>();
for(int i = Smeltables.Count - 1; i >= 0; i--)
{
Item item = Smeltables[ i ];
if( item is BaseArmor )
{
if( Resmelt( from, item, ( (BaseArmor)item ).Resource ) )
salvaged++;
else
notSalvaged++;
}
else if( item is BaseWeapon )
{
if( Resmelt( from, item, ( (BaseWeapon)item ).Resource ) )
salvaged++;
else
notSalvaged++;
}
else if( item is DragonBardingDeed )
{
if( Resmelt( from, item, ( (DragonBardingDeed)item ).Resource ) )
salvaged++;
else
notSalvaged++;
}
}
if( m_Failure )
{
from.SendLocalizedMessage( 1079975 ); // You failed to smelt some metal for lack of skill.
m_Failure = false;
}
else
from.SendLocalizedMessage( 1079973, String.Format( "{0}\t{1}", salvaged, salvaged + notSalvaged ) ); // Salvaged: ~1_COUNT~/~2_NUM~ blacksmithed items
}
private void SalvageCloth( Mobile from )
{
Scissors scissors = from.Backpack.FindItemByType( typeof( Scissors ) ) as Scissors;
if( scissors == null )
{
from.SendLocalizedMessage( 1079823 ); // You need scissors in order to salvage cloth.
return;
}
int salvaged = 0;
int notSalvaged = 0;
Container sBag = this;
List<Item> scissorables = sBag.FindItemsByType<Item>();
for ( int i = scissorables.Count - 1; i >= 0; --i )
{
Item item = scissorables[i];
if ( item is IScissorable )
{
IScissorable scissorable = (IScissorable)item;
if ( Scissors.CanScissor( from, scissorable ) && scissorable.Scissor( from, scissors ) )
++salvaged;
else
++notSalvaged;
}
}
from.SendLocalizedMessage( 1079974, String.Format( "{0}\t{1}", salvaged, salvaged + notSalvaged ) ); // Salvaged: ~1_COUNT~/~2_NUM~ tailored items
Container pack = from.Backpack;
foreach (Item i in ((Container)this).FindItemsByType(typeof(Item), true))
{
if( ( i is Leather ) || ( i is Cloth ) || ( i is SpinedLeather ) || ( i is HornedLeather ) || ( i is BarbedLeather ) || ( i is Bandage ) || ( i is Bone ) )
{
from.AddToBackpack( i );
}
}
}
private void SalvageAll( Mobile from )
{
SalvageIngots( from );
SalvageCloth( from );
}
#endregion
#region ContextMenuEntries
private class SalvageAllEntry : ContextMenuEntry
{
private SalvageBag m_Bag;
public SalvageAllEntry( SalvageBag bag, bool enabled )
: base( 6276 )
{
m_Bag = bag;
if( !enabled )
Flags |= CMEFlags.Disabled;
}
public override void OnClick()
{
if( m_Bag.Deleted )
return;
Mobile from = Owner.From;
if( from.CheckAlive() )
m_Bag.SalvageAll( from );
}
}
private class SalvageIngotsEntry : ContextMenuEntry
{
private SalvageBag m_Bag;
public SalvageIngotsEntry( SalvageBag bag, bool enabled )
: base( 6277 )
{
m_Bag = bag;
if( !enabled )
Flags |= CMEFlags.Disabled;
}
public override void OnClick()
{
if( m_Bag.Deleted )
return;
Mobile from = Owner.From;
if( from.CheckAlive() )
m_Bag.SalvageIngots( from );
}
}
private class SalvageClothEntry : ContextMenuEntry
{
private SalvageBag m_Bag;
public SalvageClothEntry( SalvageBag bag, bool enabled )
: base( 6278 )
{
m_Bag = bag;
if( !enabled )
Flags |= CMEFlags.Disabled;
}
public override void OnClick()
{
if( m_Bag.Deleted )
return;
Mobile from = Owner.From;
if( from.CheckAlive() )
m_Bag.SalvageCloth( from );
}
}
#endregion
#region Serialization
public SalvageBag( Serial serial )
: base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.WriteEncodedInt( (int)0 ); // version
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadEncodedInt();
}
#endregion
}
}

170
Scripts/Items/Containers/Strongbox.cs Normal file
View file

@ -0,0 +1,170 @@
using System;
using System.Collections.Generic;
using Server;
using Server.Multis;
using Server.Network;
namespace Server.Items
{
[FlipableAttribute( 0xE80, 0x9A8 )]
public class StrongBox : BaseContainer, IChopable
{
private Mobile m_Owner;
private BaseHouse m_House;
public override double DefaultWeight{ get{ return 100; } }
public override int LabelNumber { get { return 1023712; } }
public StrongBox( Mobile owner, BaseHouse house ) : base( 0xE80 )
{
m_Owner = owner;
m_House = house;
MaxItems = 25;
}
[CommandProperty( AccessLevel.GameMaster )]
public Mobile Owner
{
get
{
return m_Owner;
}
set
{
m_Owner = value;
InvalidateProperties();
}
}
public override int DefaultMaxWeight{ get{ return 0; } }
public StrongBox( Serial serial ) : base(serial)
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 0 ); // version
writer.Write( m_Owner );
writer.Write( m_House );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 0:
{
m_Owner = reader.ReadMobile();
m_House = reader.ReadItem() as BaseHouse;
break;
}
}
Timer.DelayCall( TimeSpan.FromSeconds( 1.0 ), new TimerCallback( Validate ) );
}
private void Validate()
{
if ( m_Owner != null && m_House != null && !m_House.IsCoOwner( m_Owner ) )
{
Console.WriteLine( "Warning: Destroying strongbox of {0}", m_Owner.Name );
Destroy();
}
}
public override bool Decays
{
get
{
if ( m_House != null && m_Owner != null && !m_Owner.Deleted )
return !m_House.IsCoOwner( m_Owner );
else
return true;
}
}
public override TimeSpan DecayTime
{
get
{
return TimeSpan.FromMinutes( 30.0 );
}
}
public override void AddNameProperty( ObjectPropertyList list )
{
if ( m_Owner != null )
list.Add( 1042887, m_Owner.Name ); // a strong box owned by ~1_OWNER_NAME~
else
base.AddNameProperty( list );
}
public override void OnSingleClick( Mobile from )
{
if ( m_Owner != null )
{
LabelTo( from, 1042887, m_Owner.Name ); // a strong box owned by ~1_OWNER_NAME~
if ( CheckContentDisplay( from ) )
LabelTo( from, "({0} items, {1} stones)", TotalItems, TotalWeight );
}
else
{
base.OnSingleClick( from );
}
}
public override bool IsAccessibleTo( Mobile m )
{
if ( m_Owner == null || m_Owner.Deleted || m_House == null || m_House.Deleted || m.AccessLevel >= AccessLevel.GameMaster )
return true;
return m == m_Owner && m_House.IsCoOwner( m ) && base.IsAccessibleTo( m );
}
private void Chop( Mobile from )
{
Effects.PlaySound( Location, Map, 0x3B3 );
from.SendLocalizedMessage( 500461 ); // You destroy the item.
Destroy();
}
public void OnChop( Mobile from )
{
if ( m_House != null && !m_House.Deleted && m_Owner != null && !m_Owner.Deleted )
{
if ( from == m_Owner || m_House.IsOwner( from ) )
Chop( from );
}
else
{
Chop( from );
}
}
public Container ConvertToStandardContainer()
{
Container metalBox = new MetalBox();
List<Item> subItems = new List<Item>( Items );
foreach ( Item subItem in subItems )
{
metalBox.AddItem( subItem );
}
this.Delete();
return metalBox;
}
}
}

260
Scripts/Items/Containers/TrapableContainer.cs Normal file
View file

@ -0,0 +1,260 @@
using System;
namespace Server.Items
{
public enum TrapType
{
None,
MagicTrap,
ExplosionTrap,
DartTrap,
PoisonTrap
}
public abstract class TrapableContainer : BaseContainer, ITelekinesisable
{
private TrapType m_TrapType;
private int m_TrapPower;
private int m_TrapLevel;
[CommandProperty( AccessLevel.GameMaster )]
public TrapType TrapType
{
get
{
return m_TrapType;
}
set
{
m_TrapType = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public int TrapPower
{
get
{
return m_TrapPower;
}
set
{
m_TrapPower = value;
}
}
[CommandProperty( AccessLevel.GameMaster )]
public int TrapLevel
{
get
{
return m_TrapLevel;
}
set
{
m_TrapLevel = value;
}
}
public virtual bool TrapOnOpen{ get{ return true; } }
public TrapableContainer( int itemID ) : base( itemID )
{
}
public TrapableContainer( Serial serial ) : base( serial )
{
}
private void SendMessageTo( Mobile to, int number, int hue )
{
if ( Deleted || !to.CanSee( this ) )
return;
to.Send( new Network.MessageLocalized( Serial, ItemID, Network.MessageType.Regular, hue, 3, number, "", "" ) );
}
private void SendMessageTo( Mobile to, string text, int hue )
{
if ( Deleted || !to.CanSee( this ) )
return;
to.Send( new Network.UnicodeMessage( Serial, ItemID, Network.MessageType.Regular, hue, 3, "ENU", "", text ) );
}
public virtual bool ExecuteTrap( Mobile from )
{
if ( m_TrapType != TrapType.None )
{
Point3D loc = this.GetWorldLocation();
Map facet = this.Map;
if ( from.AccessLevel >= AccessLevel.GameMaster )
{
SendMessageTo( from, "That is trapped, but you open it with your godly powers.", 0x3B2 );
return false;
}
switch ( m_TrapType )
{
case TrapType.ExplosionTrap:
{
SendMessageTo( from, 502999, 0x3B2 ); // You set off a trap!
if ( from.InRange( loc, 3 ) )
{
int damage;
if ( m_TrapLevel > 0 )
damage = Utility.RandomMinMax( 10, 30 ) * m_TrapLevel;
else
damage = m_TrapPower;
AOS.Damage( from, damage, 0, 100, 0, 0, 0 );
// Your skin blisters from the heat!
from.LocalOverheadMessage( Network.MessageType.Regular, 0x2A, 503000 );
}
Effects.SendLocationEffect( loc, facet, 0x36BD, 15, 10 );
Effects.PlaySound( loc, facet, 0x307 );
break;
}
case TrapType.MagicTrap:
{
if ( from.InRange( loc, 1 ) )
from.Damage( m_TrapPower );
//AOS.Damage( from, m_TrapPower, 0, 100, 0, 0, 0 );
Effects.PlaySound( loc, Map, 0x307 );
Effects.SendLocationEffect( new Point3D( loc.X - 1, loc.Y, loc.Z ), Map, 0x36BD, 15 );
Effects.SendLocationEffect( new Point3D( loc.X + 1, loc.Y, loc.Z ), Map, 0x36BD, 15 );
Effects.SendLocationEffect( new Point3D( loc.X, loc.Y - 1, loc.Z ), Map, 0x36BD, 15 );
Effects.SendLocationEffect( new Point3D( loc.X, loc.Y + 1, loc.Z ), Map, 0x36BD, 15 );
Effects.SendLocationEffect( new Point3D( loc.X + 1, loc.Y + 1, loc.Z + 11 ), Map, 0x36BD, 15 );
break;
}
case TrapType.DartTrap:
{
SendMessageTo( from, 502999, 0x3B2 ); // You set off a trap!
if ( from.InRange( loc, 3 ) )
{
int damage;
if ( m_TrapLevel > 0 )
damage = Utility.RandomMinMax( 5, 15 ) * m_TrapLevel;
else
damage = m_TrapPower;
AOS.Damage( from, damage, 100, 0, 0, 0, 0 );
// A dart imbeds itself in your flesh!
from.LocalOverheadMessage( Network.MessageType.Regular, 0x62, 502998 );
}
Effects.PlaySound( loc, facet, 0x223 );
break;
}
case TrapType.PoisonTrap:
{
SendMessageTo( from, 502999, 0x3B2 ); // You set off a trap!
if ( from.InRange( loc, 3 ) )
{
Poison poison;
if ( m_TrapLevel > 0 )
{
poison = Poison.GetPoison( Math.Max( 0, Math.Min( 4, m_TrapLevel - 1 ) ) );
}
else
{
AOS.Damage( from, m_TrapPower, 0, 0, 0, 100, 0 );
poison = Poison.Greater;
}
from.ApplyPoison( from, poison );
// You are enveloped in a noxious green cloud!
from.LocalOverheadMessage( Network.MessageType.Regular, 0x44, 503004 );
}
Effects.SendLocationEffect( loc, facet, 0x113A, 10, 20 );
Effects.PlaySound( loc, facet, 0x231 );
break;
}
}
m_TrapType = TrapType.None;
m_TrapPower = 0;
m_TrapLevel = 0;
return true;
}
return false;
}
public virtual void OnTelekinesis( Mobile from )
{
Effects.SendLocationParticles( EffectItem.Create( Location, Map, EffectItem.DefaultDuration ), 0x376A, 9, 32, 5022 );
Effects.PlaySound( Location, Map, 0x1F5 );
if( this.TrapOnOpen )
{
ExecuteTrap( from );
}
}
public override void Open( Mobile from )
{
if ( !this.TrapOnOpen || !ExecuteTrap( from ) )
base.Open( from );
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 2 ); // version
writer.Write( (int) m_TrapLevel );
writer.Write( (int) m_TrapPower );
writer.Write( (int) m_TrapType );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 2:
{
m_TrapLevel = reader.ReadInt();
goto case 1;
}
case 1:
{
m_TrapPower = reader.ReadInt();
goto case 0;
}
case 0:
{
m_TrapType = (TrapType)reader.ReadInt();
break;
}
}
}
}
}

89
Scripts/Items/Containers/TreasureChest.cs Normal file
View file

@ -0,0 +1,89 @@
using Server;
using Server.Items;
using Server.Multis;
using Server.Network;
using System;
namespace Server.Items
{
[FlipableAttribute( 0xe43, 0xe42 )]
public class WoodenTreasureChest : BaseTreasureChest
{
[Constructable]
public WoodenTreasureChest() : base( 0xE43 )
{
}
public WoodenTreasureChest( Serial serial ) : base( serial )
{
}
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();
}
}
[FlipableAttribute( 0xe41, 0xe40 )]
public class MetalGoldenTreasureChest : BaseTreasureChest
{
[Constructable]
public MetalGoldenTreasureChest() : base( 0xE41 )
{
}
public MetalGoldenTreasureChest( Serial serial ) : base( serial )
{
}
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();
}
}
[FlipableAttribute( 0x9ab, 0xe7c )]
public class MetalTreasureChest : BaseTreasureChest
{
[Constructable]
public MetalTreasureChest() : base( 0x9AB )
{
}
public MetalTreasureChest( Serial serial ) : base( serial )
{
}
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();
}
}
}

575
Scripts/Items/Containers/TreasureMapChest.cs Normal file
View file

@ -0,0 +1,575 @@
using System;
using System.Collections.Generic;
using Server;
using Server.ContextMenus;
using Server.Engines.PartySystem;
using Server.Gumps;
using Server.Multis;
using Server.Network;
namespace Server.Items
{
public class TreasureMapChest : LockableContainer
{
public override int LabelNumber{ get{ return 3000541; } }
public static Type[] Artifacts { get { return m_Artifacts; } }
private static Type[] m_Artifacts = new Type[]
{
typeof( CandelabraOfSouls ), typeof( GoldBricks ), typeof( PhillipsWoodenSteed ),
typeof( ArcticDeathDealer ), typeof( BlazeOfDeath ), typeof( BurglarsBandana ),
typeof( CavortingClub ), typeof( DreadPirateHat ),
typeof( EnchantedTitanLegBone ), typeof( GwennosHarp ), typeof( IolosLute ),
typeof( LunaLance ), typeof( NightsKiss ), typeof( NoxRangersHeavyCrossbow ),
typeof( PolarBearMask ), typeof( VioletCourage ), typeof( HeartOfTheLion ),
typeof( ColdBlood ), typeof( AlchemistsBauble )
};
private int m_Level;
private DateTime m_DeleteTime;
private Timer m_Timer;
private Mobile m_Owner;
private bool m_Temporary;
private List<Mobile> m_Guardians;
[CommandProperty( AccessLevel.GameMaster )]
public int Level{ get{ return m_Level; } set{ m_Level = value; } }
[CommandProperty( AccessLevel.GameMaster )]
public Mobile Owner{ get{ return m_Owner; } set{ m_Owner = value; } }
[CommandProperty( AccessLevel.GameMaster )]
public DateTime DeleteTime{ get{ return m_DeleteTime; } }
[CommandProperty( AccessLevel.GameMaster )]
public bool Temporary{ get{ return m_Temporary; } set{ m_Temporary = value; } }
public List<Mobile> Guardians { get { return m_Guardians; } }
[Constructable]
public TreasureMapChest( int level ) : this( null, level, false )
{
}
public TreasureMapChest( Mobile owner, int level, bool temporary ) : base( 0xE40 )
{
m_Owner = owner;
m_Level = level;
m_DeleteTime = DateTime.UtcNow + TimeSpan.FromHours( 3.0 );
m_Temporary = temporary;
m_Guardians = new List<Mobile>();
m_Timer = new DeleteTimer( this, m_DeleteTime );
m_Timer.Start();
Fill( this, level );
}
private static void GetRandomAOSStats( out int attributeCount, out int min, out int max )
{
int rnd = Utility.Random( 15 );
if ( Core.SE )
{
if ( rnd < 1 )
{
attributeCount = Utility.RandomMinMax( 3, 5 );
min = 50; max = 100;
}
else if ( rnd < 3 )
{
attributeCount = Utility.RandomMinMax( 2, 5 );
min = 40; max = 80;
}
else if ( rnd < 6 )
{
attributeCount = Utility.RandomMinMax( 2, 4 );
min = 30; max = 60;
}
else if ( rnd < 10 )
{
attributeCount = Utility.RandomMinMax( 1, 3 );
min = 20; max = 40;
}
else
{
attributeCount = 1;
min = 10; max = 20;
}
}
else
{
if ( rnd < 1 )
{
attributeCount = Utility.RandomMinMax( 2, 5 );
min = 20; max = 70;
}
else if ( rnd < 3 )
{
attributeCount = Utility.RandomMinMax( 2, 4 );
min = 20; max = 50;
}
else if ( rnd < 6 )
{
attributeCount = Utility.RandomMinMax( 2, 3 );
min = 20; max = 40;
}
else if ( rnd < 10 )
{
attributeCount = Utility.RandomMinMax( 1, 2 );
min = 10; max = 30;
}
else
{
attributeCount = 1;
min = 10; max = 20;
}
}
}
public static void Fill( LockableContainer cont, int level )
{
cont.Movable = false;
cont.Locked = true;
int numberItems;
if ( level == 0 )
{
cont.LockLevel = 0; // Can't be unlocked
cont.DropItem( new Gold( Utility.RandomMinMax( 50, 100 ) ) );
if ( Utility.RandomDouble() < 0.75 )
cont.DropItem( new TreasureMap( 0, Map.Trammel ) );
}
else
{
cont.TrapType = TrapType.ExplosionTrap;
cont.TrapPower = level * 25;
cont.TrapLevel = level;
switch ( level )
{
case 1: cont.RequiredSkill = 36; break;
case 2: cont.RequiredSkill = 76; break;
case 3: cont.RequiredSkill = 84; break;
case 4: cont.RequiredSkill = 92; break;
case 5: cont.RequiredSkill = 100; break;
case 6: cont.RequiredSkill = 100; break;
}
cont.LockLevel = cont.RequiredSkill - 10;
cont.MaxLockLevel = cont.RequiredSkill + 40;
//Publish 67 gold change
//if ( Core.SA )
// cont.DropItem( new Gold( level * 5000 ) );
//else
cont.DropItem( new Gold( level * 1000 ) );
for ( int i = 0; i < level * 5; ++i )
cont.DropItem( Loot.RandomScroll( 0, 63, SpellbookType.Regular ) );
if ( Core.SE)
{
switch ( level )
{
case 1: numberItems = 5; break;
case 2: numberItems = 10; break;
case 3: numberItems = 15; break;
case 4: numberItems = 38; break;
case 5: numberItems = 50; break;
case 6: numberItems = 60; break;
default: numberItems = 0; break;
};
}
else
numberItems = level * 6;
for ( int i = 0; i < numberItems; ++i )
{
Item item;
if ( Core.AOS )
item = Loot.RandomArmorOrShieldOrWeaponOrJewelry();
else
item = Loot.RandomArmorOrShieldOrWeapon();
if ( item is BaseWeapon )
{
BaseWeapon weapon = (BaseWeapon)item;
if ( Core.AOS )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( weapon, attributeCount, min, max );
}
else
{
weapon.DamageLevel = (WeaponDamageLevel)Utility.Random( 6 );
weapon.AccuracyLevel = (WeaponAccuracyLevel)Utility.Random( 6 );
weapon.DurabilityLevel = (WeaponDurabilityLevel)Utility.Random( 6 );
}
cont.DropItem( item );
}
else if ( item is BaseArmor )
{
BaseArmor armor = (BaseArmor)item;
if ( Core.AOS )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( armor, attributeCount, min, max );
}
else
{
armor.ProtectionLevel = (ArmorProtectionLevel)Utility.Random( 6 );
armor.Durability = (ArmorDurabilityLevel)Utility.Random( 6 );
}
cont.DropItem( item );
}
else if( item is BaseHat )
{
BaseHat hat = (BaseHat)item;
if( Core.AOS )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( hat, attributeCount, min, max );
}
cont.DropItem( item );
}
else if( item is BaseJewel )
{
int attributeCount;
int min, max;
GetRandomAOSStats( out attributeCount, out min, out max );
BaseRunicTool.ApplyAttributesTo( (BaseJewel)item, attributeCount, min, max );
cont.DropItem( item );
}
}
}
int reagents;
if ( level == 0 )
reagents = 12;
else
reagents = level * 3;
for ( int i = 0; i < reagents; i++ )
{
Item item = Loot.RandomPossibleReagent();
item.Amount = Utility.RandomMinMax( 40, 60 );
cont.DropItem( item );
}
int gems;
if ( level == 0 )
gems = 2;
else
gems = level * 3;
for ( int i = 0; i < gems; i++ )
{
Item item = Loot.RandomGem();
cont.DropItem( item );
}
if ( level == 6 && Core.AOS )
cont.DropItem( (Item)Activator.CreateInstance( m_Artifacts[Utility.Random(m_Artifacts.Length)] ) );
}
public override bool CheckLocked( Mobile from )
{
if ( !this.Locked )
return false;
if ( this.Level == 0 && from.AccessLevel < AccessLevel.GameMaster )
{
foreach ( Mobile m in this.Guardians )
{
if ( m.Alive )
{
from.SendLocalizedMessage( 1046448 ); // You must first kill the guardians before you may open this chest.
return true;
}
}
LockPick( from );
return false;
}
else
{
return base.CheckLocked( from );
}
}
private List<Item> m_Lifted = new List<Item>();
private bool CheckLoot( Mobile m, bool criminalAction )
{
if ( m_Temporary )
return false;
if ( m.AccessLevel >= AccessLevel.GameMaster || m_Owner == null || m == m_Owner )
return true;
Party p = Party.Get( m_Owner );
if ( p != null && p.Contains( m ) )
return true;
Map map = this.Map;
if ( map != null && (map.Rules & MapRules.HarmfulRestrictions) == 0 )
{
if ( criminalAction )
m.CriminalAction( true );
else
m.SendLocalizedMessage( 1010630 ); // Taking someone else's treasure is a criminal offense!
return true;
}
m.SendLocalizedMessage( 1010631 ); // You did not discover this chest!
return false;
}
public override bool IsDecoContainer
{
get{ return false; }
}
public override bool CheckItemUse( Mobile from, Item item )
{
return CheckLoot( from, item != this ) && base.CheckItemUse( from, item );
}
public override bool CheckLift( Mobile from, Item item, ref LRReason reject )
{
return CheckLoot( from, true ) && base.CheckLift( from, item, ref reject );
}
public override void OnItemLifted( Mobile from, Item item )
{
bool notYetLifted = !m_Lifted.Contains( item );
from.RevealingAction();
if ( notYetLifted )
{
m_Lifted.Add( item );
if ( 0.1 >= Utility.RandomDouble() ) // 10% chance to spawn a new monster
TreasureMap.Spawn( m_Level, GetWorldLocation(), Map, from, false );
}
base.OnItemLifted( from, item );
}
public override bool CheckHold( Mobile m, Item item, bool message, bool checkItems, int plusItems, int plusWeight )
{
if ( m.AccessLevel < AccessLevel.GameMaster )
{
m.SendLocalizedMessage( 1048122, "", 0x8A5 ); // The chest refuses to be filled with treasure again.
return false;
}
return base.CheckHold( m, item, message, checkItems, plusItems, plusWeight );
}
public TreasureMapChest( Serial serial ) : base( serial )
{
}
public override void Serialize( GenericWriter writer )
{
base.Serialize( writer );
writer.Write( (int) 2 ); // version
writer.Write( m_Guardians, true );
writer.Write( (bool) m_Temporary );
writer.Write( m_Owner );
writer.Write( (int) m_Level );
writer.WriteDeltaTime( m_DeleteTime );
writer.Write( m_Lifted, true );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadInt();
switch ( version )
{
case 2:
{
m_Guardians = reader.ReadStrongMobileList();
m_Temporary = reader.ReadBool();
goto case 1;
}
case 1:
{
m_Owner = reader.ReadMobile();
goto case 0;
}
case 0:
{
m_Level = reader.ReadInt();
m_DeleteTime = reader.ReadDeltaTime();
m_Lifted = reader.ReadStrongItemList();
if ( version < 2 )
m_Guardians = new List<Mobile>();
break;
}
}
if ( !m_Temporary )
{
m_Timer = new DeleteTimer( this, m_DeleteTime );
m_Timer.Start();
}
else
{
Delete();
}
}
public override void OnAfterDelete()
{
if ( m_Timer != null )
m_Timer.Stop();
m_Timer = null;
base.OnAfterDelete();
}
public override void GetContextMenuEntries( Mobile from, List<ContextMenuEntry> list )
{
base.GetContextMenuEntries( from, list );
if ( from.Alive )
list.Add( new RemoveEntry( from, this ) );
}
public void BeginRemove( Mobile from )
{
if ( !from.Alive )
return;
from.CloseGump( typeof( RemoveGump ) );
from.SendGump( new RemoveGump( from, this ) );
}
public void EndRemove( Mobile from )
{
if ( Deleted || from != m_Owner || !from.InRange( GetWorldLocation(), 3 ) )
return;
from.SendLocalizedMessage( 1048124, "", 0x8A5 ); // The old, rusted chest crumbles when you hit it.
this.Delete();
}
private class RemoveGump : Gump
{
private Mobile m_From;
private TreasureMapChest m_Chest;
public RemoveGump( Mobile from, TreasureMapChest chest ) : base( 15, 15 )
{
m_From = from;
m_Chest = chest;
Closable = false;
Disposable = false;
AddPage( 0 );
AddBackground( 30, 0, 240, 240, 2620 );
AddHtmlLocalized( 45, 15, 200, 80, 1048125, 0xFFFFFF, false, false ); // When this treasure chest is removed, any items still inside of it will be lost.
AddHtmlLocalized( 45, 95, 200, 60, 1048126, 0xFFFFFF, false, false ); // Are you certain you're ready to remove this chest?
AddButton( 40, 153, 4005, 4007, 1, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 75, 155, 180, 40, 1048127, 0xFFFFFF, false, false ); // Remove the Treasure Chest
AddButton( 40, 195, 4005, 4007, 2, GumpButtonType.Reply, 0 );
AddHtmlLocalized( 75, 197, 180, 35, 1006045, 0xFFFFFF, false, false ); // Cancel
}
public override void OnResponse( NetState sender, RelayInfo info )
{
if ( info.ButtonID == 1 )
m_Chest.EndRemove( m_From );
}
}
private class RemoveEntry : ContextMenuEntry
{
private Mobile m_From;
private TreasureMapChest m_Chest;
public RemoveEntry( Mobile from, TreasureMapChest chest ) : base( 6149, 3 )
{
m_From = from;
m_Chest = chest;
Enabled = ( from == chest.Owner );
}
public override void OnClick()
{
if ( m_Chest.Deleted || m_From != m_Chest.Owner || !m_From.CheckAlive() )
return;
m_Chest.BeginRemove( m_From );
}
}
private class DeleteTimer : Timer
{
private Item m_Item;
public DeleteTimer( Item item, DateTime time ) : base( time - DateTime.UtcNow )
{
m_Item = item;
Priority = TimerPriority.OneMinute;
}
protected override void OnTick()
{
m_Item.Delete();
}
}
}
}