934 lines
29 KiB
C#
934 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Server.Gumps;
|
|
using Server.Network;
|
|
|
|
namespace Server.Items
|
|
{
|
|
public enum PuzzleChestCylinder
|
|
{
|
|
None = 0xE73,
|
|
LightBlue = 0x186F,
|
|
Blue = 0x186A,
|
|
Green = 0x186B,
|
|
Orange = 0x186C,
|
|
Purple = 0x186D,
|
|
Red = 0x186E,
|
|
DarkBlue = 0x1869,
|
|
Yellow = 0x1870
|
|
}
|
|
|
|
public class PuzzleChestSolution
|
|
{
|
|
public const int Length = 5;
|
|
private readonly PuzzleChestCylinder[] m_Cylinders = new PuzzleChestCylinder[Length];
|
|
public PuzzleChestSolution()
|
|
{
|
|
for (int i = 0; i < m_Cylinders.Length; i++)
|
|
{
|
|
m_Cylinders[i] = RandomCylinder();
|
|
}
|
|
}
|
|
|
|
public PuzzleChestSolution(PuzzleChestCylinder first, PuzzleChestCylinder second, PuzzleChestCylinder third, PuzzleChestCylinder fourth, PuzzleChestCylinder fifth)
|
|
{
|
|
First = first;
|
|
Second = second;
|
|
Third = third;
|
|
Fourth = fourth;
|
|
Fifth = fifth;
|
|
}
|
|
|
|
public PuzzleChestSolution(PuzzleChestSolution solution)
|
|
{
|
|
for (int i = 0; i < m_Cylinders.Length; i++)
|
|
{
|
|
m_Cylinders[i] = solution.m_Cylinders[i];
|
|
}
|
|
}
|
|
|
|
public PuzzleChestSolution(GenericReader reader)
|
|
{
|
|
int version = reader.ReadEncodedInt();
|
|
|
|
int length = reader.ReadEncodedInt();
|
|
for (int i = 0;; i++)
|
|
{
|
|
if (i < length)
|
|
{
|
|
PuzzleChestCylinder cylinder = (PuzzleChestCylinder)reader.ReadInt();
|
|
|
|
if (i < m_Cylinders.Length)
|
|
m_Cylinders[i] = cylinder;
|
|
}
|
|
else if (i < m_Cylinders.Length)
|
|
{
|
|
m_Cylinders[i] = RandomCylinder();
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public PuzzleChestCylinder[] Cylinders
|
|
{
|
|
get
|
|
{
|
|
return m_Cylinders;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder First
|
|
{
|
|
get
|
|
{
|
|
return m_Cylinders[0];
|
|
}
|
|
set
|
|
{
|
|
m_Cylinders[0] = value;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder Second
|
|
{
|
|
get
|
|
{
|
|
return m_Cylinders[1];
|
|
}
|
|
set
|
|
{
|
|
m_Cylinders[1] = value;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder Third
|
|
{
|
|
get
|
|
{
|
|
return m_Cylinders[2];
|
|
}
|
|
set
|
|
{
|
|
m_Cylinders[2] = value;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder Fourth
|
|
{
|
|
get
|
|
{
|
|
return m_Cylinders[3];
|
|
}
|
|
set
|
|
{
|
|
m_Cylinders[3] = value;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder Fifth
|
|
{
|
|
get
|
|
{
|
|
return m_Cylinders[4];
|
|
}
|
|
set
|
|
{
|
|
m_Cylinders[4] = value;
|
|
}
|
|
}
|
|
public static PuzzleChestCylinder RandomCylinder()
|
|
{
|
|
switch ( Utility.Random(8) )
|
|
{
|
|
case 0:
|
|
return PuzzleChestCylinder.LightBlue;
|
|
case 1:
|
|
return PuzzleChestCylinder.Blue;
|
|
case 2:
|
|
return PuzzleChestCylinder.Green;
|
|
case 3:
|
|
return PuzzleChestCylinder.Orange;
|
|
case 4:
|
|
return PuzzleChestCylinder.Purple;
|
|
case 5:
|
|
return PuzzleChestCylinder.Red;
|
|
case 6:
|
|
return PuzzleChestCylinder.DarkBlue;
|
|
default:
|
|
return PuzzleChestCylinder.Yellow;
|
|
}
|
|
}
|
|
|
|
public bool Matches(PuzzleChestSolution solution, out int cylinders, out int colors)
|
|
{
|
|
cylinders = 0;
|
|
colors = 0;
|
|
|
|
bool[] matchesSrc = new bool[solution.m_Cylinders.Length];
|
|
bool[] matchesDst = new bool[solution.m_Cylinders.Length];
|
|
|
|
for (int i = 0; i < m_Cylinders.Length; i++)
|
|
{
|
|
if (m_Cylinders[i] == solution.m_Cylinders[i])
|
|
{
|
|
cylinders++;
|
|
|
|
matchesSrc[i] = true;
|
|
matchesDst[i] = true;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < m_Cylinders.Length; i++)
|
|
{
|
|
if (!matchesSrc[i])
|
|
{
|
|
for (int j = 0; j < solution.m_Cylinders.Length; j++)
|
|
{
|
|
if (m_Cylinders[i] == solution.m_Cylinders[j] && !matchesDst[j])
|
|
{
|
|
colors++;
|
|
|
|
matchesDst[j] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return cylinders == m_Cylinders.Length;
|
|
}
|
|
|
|
public virtual void Serialize(GenericWriter writer)
|
|
{
|
|
writer.WriteEncodedInt((int)0); // version
|
|
|
|
writer.WriteEncodedInt((int)m_Cylinders.Length);
|
|
for (int i = 0; i < m_Cylinders.Length; i++)
|
|
{
|
|
writer.Write((int)m_Cylinders[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
public class PuzzleChestSolutionAndTime : PuzzleChestSolution
|
|
{
|
|
private readonly DateTime m_When;
|
|
public PuzzleChestSolutionAndTime(DateTime when, PuzzleChestSolution solution)
|
|
: base(solution)
|
|
{
|
|
m_When = when;
|
|
}
|
|
|
|
public PuzzleChestSolutionAndTime(GenericReader reader)
|
|
: base(reader)
|
|
{
|
|
int version = reader.ReadEncodedInt();
|
|
|
|
m_When = reader.ReadDeltaTime();
|
|
}
|
|
|
|
public DateTime When
|
|
{
|
|
get
|
|
{
|
|
return m_When;
|
|
}
|
|
}
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
base.Serialize(writer);
|
|
|
|
writer.WriteEncodedInt((int)0); // version
|
|
|
|
writer.WriteDeltaTime(m_When);
|
|
}
|
|
}
|
|
|
|
public abstract class PuzzleChest : BaseTreasureChest
|
|
{
|
|
public const int HintsCount = 3;
|
|
public readonly TimeSpan CleanupTime = TimeSpan.FromHours(1.0);
|
|
private readonly Dictionary<Mobile, PuzzleChestSolutionAndTime> m_Guesses = new Dictionary<Mobile, PuzzleChestSolutionAndTime>();
|
|
private PuzzleChestSolution m_Solution;
|
|
private PuzzleChestCylinder[] m_Hints = new PuzzleChestCylinder[HintsCount];
|
|
|
|
public virtual int Label { get { return 1018309; } } // A Puzzle Lock
|
|
|
|
public PuzzleChest(int itemID)
|
|
: base(itemID)
|
|
{
|
|
}
|
|
|
|
public PuzzleChest(Serial serial)
|
|
: base(serial)
|
|
{
|
|
}
|
|
|
|
public PuzzleChestSolution Solution
|
|
{
|
|
get
|
|
{
|
|
return m_Solution;
|
|
}
|
|
set
|
|
{
|
|
m_Solution = value;
|
|
InitHints();
|
|
}
|
|
}
|
|
public PuzzleChestCylinder[] Hints
|
|
{
|
|
get
|
|
{
|
|
return m_Hints;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder FirstHint
|
|
{
|
|
get
|
|
{
|
|
return m_Hints[0];
|
|
}
|
|
set
|
|
{
|
|
m_Hints[0] = value;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder SecondHint
|
|
{
|
|
get
|
|
{
|
|
return m_Hints[1];
|
|
}
|
|
set
|
|
{
|
|
m_Hints[1] = value;
|
|
}
|
|
}
|
|
public PuzzleChestCylinder ThirdHint
|
|
{
|
|
get
|
|
{
|
|
return m_Hints[2];
|
|
}
|
|
set
|
|
{
|
|
m_Hints[2] = value;
|
|
}
|
|
}
|
|
public override string DefaultName
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
public override bool CheckLocked(Mobile from)
|
|
{
|
|
if (Locked)
|
|
{
|
|
PuzzleChestSolution solution = GetLastGuess(from);
|
|
if (solution != null)
|
|
solution = new PuzzleChestSolution(solution);
|
|
else
|
|
solution = new PuzzleChestSolution(PuzzleChestCylinder.None, PuzzleChestCylinder.None, PuzzleChestCylinder.None, PuzzleChestCylinder.None, PuzzleChestCylinder.None);
|
|
|
|
from.CloseGump(typeof(PuzzleGump));
|
|
from.CloseGump(typeof(StatusGump));
|
|
from.SendGump(new PuzzleGump(from, this, solution, 0));
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public PuzzleChestSolutionAndTime GetLastGuess(Mobile m)
|
|
{
|
|
PuzzleChestSolutionAndTime pcst = null;
|
|
m_Guesses.TryGetValue(m, out pcst);
|
|
return pcst;
|
|
}
|
|
|
|
public void SubmitSolution(Mobile m, PuzzleChestSolution solution)
|
|
{
|
|
int correctCylinders, correctColors;
|
|
|
|
if (solution.Matches(Solution, out correctCylinders, out correctColors))
|
|
{
|
|
LockPick(m);
|
|
|
|
DisplayTo(m);
|
|
}
|
|
else
|
|
{
|
|
m_Guesses[m] = new PuzzleChestSolutionAndTime(DateTime.UtcNow, solution);
|
|
|
|
m.SendGump(new StatusGump(correctCylinders, correctColors));
|
|
|
|
DoDamage(m);
|
|
}
|
|
}
|
|
|
|
public virtual void DoDamage(Mobile to)
|
|
{
|
|
switch ( Utility.Random(4) )
|
|
{
|
|
case 0:
|
|
{
|
|
Effects.SendLocationEffect(to, to.Map, 0x113A, 20, 10);
|
|
to.PlaySound(0x231);
|
|
to.LocalOverheadMessage(MessageType.Regular, 0x44, 1010523); // A toxic vapor envelops thee.
|
|
|
|
to.ApplyPoison(to, Poison.Regular);
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
Effects.SendLocationEffect(to, to.Map, 0x3709, 30);
|
|
to.PlaySound(0x54);
|
|
to.LocalOverheadMessage(MessageType.Regular, 0xEE, 1010524); // Searing heat scorches thy skin.
|
|
|
|
AOS.Damage(to, to, Utility.RandomMinMax(10, 40), 0, 100, 0, 0, 0);
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
to.PlaySound(0x223);
|
|
to.LocalOverheadMessage(MessageType.Regular, 0x62, 1010525); // Pain lances through thee from a sharp metal blade.
|
|
|
|
AOS.Damage(to, to, Utility.RandomMinMax(10, 40), 100, 0, 0, 0, 0);
|
|
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
to.BoltEffect(0);
|
|
to.LocalOverheadMessage(MessageType.Regular, 0xDA, 1010526); // Lightning arcs through thy body.
|
|
|
|
AOS.Damage(to, to, Utility.RandomMinMax(10, 40), 0, 0, 0, 0, 100);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void LockPick(Mobile from)
|
|
{
|
|
base.LockPick(from);
|
|
|
|
m_Guesses.Clear();
|
|
}
|
|
|
|
public void CleanupGuesses()
|
|
{
|
|
List<Mobile> toDelete = new List<Mobile>();
|
|
|
|
foreach (KeyValuePair<Mobile, PuzzleChestSolutionAndTime> kvp in m_Guesses)
|
|
{
|
|
if (DateTime.UtcNow - kvp.Value.When > CleanupTime)
|
|
toDelete.Add(kvp.Key);
|
|
}
|
|
|
|
foreach (Mobile m in toDelete)
|
|
m_Guesses.Remove(m);
|
|
}
|
|
|
|
public override void Serialize(GenericWriter writer)
|
|
{
|
|
CleanupGuesses();
|
|
|
|
base.Serialize(writer);
|
|
|
|
writer.WriteEncodedInt((int)0); // version
|
|
|
|
m_Solution.Serialize(writer);
|
|
|
|
writer.WriteEncodedInt((int)m_Hints.Length);
|
|
for (int i = 0; i < m_Hints.Length; i++)
|
|
{
|
|
writer.Write((int)m_Hints[i]);
|
|
}
|
|
|
|
writer.WriteEncodedInt((int)m_Guesses.Count);
|
|
foreach (KeyValuePair<Mobile, PuzzleChestSolutionAndTime> kvp in m_Guesses)
|
|
{
|
|
writer.Write(kvp.Key);
|
|
kvp.Value.Serialize(writer);
|
|
}
|
|
}
|
|
|
|
public override void Deserialize(GenericReader reader)
|
|
{
|
|
base.Deserialize(reader);
|
|
|
|
int version = reader.ReadEncodedInt();
|
|
|
|
m_Solution = new PuzzleChestSolution(reader);
|
|
|
|
int length = reader.ReadEncodedInt();
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
PuzzleChestCylinder cylinder = (PuzzleChestCylinder)reader.ReadInt();
|
|
|
|
if (length == m_Hints.Length)
|
|
m_Hints[i] = cylinder;
|
|
}
|
|
if (length != m_Hints.Length)
|
|
InitHints();
|
|
|
|
int guesses = reader.ReadEncodedInt();
|
|
for (int i = 0; i < guesses; i++)
|
|
{
|
|
Mobile m = reader.ReadMobile();
|
|
PuzzleChestSolutionAndTime sol = new PuzzleChestSolutionAndTime(reader);
|
|
|
|
m_Guesses[m] = sol;
|
|
}
|
|
}
|
|
|
|
protected override void SetLockLevel()
|
|
{
|
|
LockLevel = 0; // Can't be unlocked
|
|
}
|
|
|
|
protected override void GenerateTreasure()
|
|
{
|
|
DropItem(new Gold(600, 900));
|
|
|
|
List<Item> gems = new List<Item>();
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
Item gem = Loot.RandomGem();
|
|
Type gemType = gem.GetType();
|
|
|
|
foreach (Item listGem in gems)
|
|
{
|
|
if (listGem.GetType() == gemType)
|
|
{
|
|
listGem.Amount++;
|
|
gem.Delete();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!gem.Deleted)
|
|
gems.Add(gem);
|
|
}
|
|
|
|
foreach (Item gem in gems)
|
|
DropItem(gem);
|
|
|
|
if (0.2 > Utility.RandomDouble())
|
|
DropItem(new BagOfReagents(50));
|
|
|
|
for (int i = 0; i < 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);
|
|
}
|
|
}
|
|
|
|
Solution = new PuzzleChestSolution();
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
private void InitHints()
|
|
{
|
|
List<PuzzleChestCylinder> list = new List<PuzzleChestCylinder>(Solution.Cylinders.Length - 1);
|
|
for (int i = 1; i < Solution.Cylinders.Length; i++)
|
|
list.Add(Solution.Cylinders[i]);
|
|
|
|
m_Hints = new PuzzleChestCylinder[HintsCount];
|
|
|
|
for (int i = 0; i < m_Hints.Length; i++)
|
|
{
|
|
int pos = Utility.Random(list.Count);
|
|
m_Hints[i] = list[pos];
|
|
list.RemoveAt(pos);
|
|
}
|
|
}
|
|
|
|
public class PuzzleGump : Gump
|
|
{
|
|
private readonly Mobile m_From;
|
|
private readonly PuzzleChest m_Chest;
|
|
private readonly PuzzleChestSolution m_Solution;
|
|
public PuzzleGump(Mobile from, PuzzleChest chest, PuzzleChestSolution solution, int check)
|
|
: base(50, 50)
|
|
{
|
|
m_From = from;
|
|
m_Chest = chest;
|
|
m_Solution = solution;
|
|
|
|
Dragable = false;
|
|
|
|
AddBackground(25, 0, 500, 410, 0x53);
|
|
|
|
AddImage(62, 20, 0x67);
|
|
|
|
AddHtmlLocalized(80, 36, 110, 70, 1018309, true, false); // A Puzzle Lock
|
|
|
|
/* Correctly choose the sequence of cylinders needed to open the latch. Each cylinder
|
|
* may potentially be used more than once. Beware! A false attempt could be deadly!
|
|
*/
|
|
AddHtmlLocalized(214, 26, 270, 90, 1018310, true, true);
|
|
|
|
AddLeftCylinderButton(62, 130, PuzzleChestCylinder.LightBlue, 10);
|
|
AddLeftCylinderButton(62, 180, PuzzleChestCylinder.Blue, 11);
|
|
AddLeftCylinderButton(62, 230, PuzzleChestCylinder.Green, 12);
|
|
AddLeftCylinderButton(62, 280, PuzzleChestCylinder.Orange, 13);
|
|
|
|
AddRightCylinderButton(451, 130, PuzzleChestCylinder.Purple, 14);
|
|
AddRightCylinderButton(451, 180, PuzzleChestCylinder.Red, 15);
|
|
AddRightCylinderButton(451, 230, PuzzleChestCylinder.DarkBlue, 16);
|
|
AddRightCylinderButton(451, 280, PuzzleChestCylinder.Yellow, 17);
|
|
|
|
double lockpicking = from.Skills.Lockpicking.Base;
|
|
if (lockpicking >= 60.0)
|
|
{
|
|
AddHtmlLocalized(160, 125, 230, 24, 1018308, false, false); // Lockpicking hint:
|
|
|
|
AddBackground(159, 150, 230, 95, 0x13EC);
|
|
|
|
if (lockpicking >= 80.0)
|
|
{
|
|
AddHtmlLocalized(165, 157, 200, 40, 1018312, false, false); // In the first slot:
|
|
AddCylinder(350, 165, chest.Solution.First);
|
|
|
|
AddHtmlLocalized(165, 197, 200, 40, 1018313, false, false); // Used in unknown slot:
|
|
AddCylinder(350, 200, chest.FirstHint);
|
|
|
|
if (lockpicking >= 90.0)
|
|
AddCylinder(350, 212, chest.SecondHint);
|
|
|
|
if (lockpicking >= 100.0)
|
|
AddCylinder(350, 224, chest.ThirdHint);
|
|
}
|
|
else
|
|
{
|
|
AddHtmlLocalized(165, 157, 200, 40, 1018313, false, false); // Used in unknown slot:
|
|
AddCylinder(350, 160, chest.FirstHint);
|
|
|
|
if (lockpicking >= 70.0)
|
|
AddCylinder(350, 172, chest.SecondHint);
|
|
}
|
|
}
|
|
|
|
PuzzleChestSolution lastGuess = chest.GetLastGuess(from);
|
|
if (lastGuess != null)
|
|
{
|
|
AddHtmlLocalized(127, 249, 170, 20, 1018311, false, false); // Thy previous guess:
|
|
|
|
AddBackground(290, 247, 115, 25, 0x13EC);
|
|
|
|
AddCylinder(281, 254, lastGuess.First);
|
|
AddCylinder(303, 254, lastGuess.Second);
|
|
AddCylinder(325, 254, lastGuess.Third);
|
|
AddCylinder(347, 254, lastGuess.Fourth);
|
|
AddCylinder(369, 254, lastGuess.Fifth);
|
|
}
|
|
|
|
AddPedestal(140, 270, solution.First, 0, check == 0);
|
|
AddPedestal(195, 270, solution.Second, 1, check == 1);
|
|
AddPedestal(250, 270, solution.Third, 2, check == 2);
|
|
AddPedestal(305, 270, solution.Fourth, 3, check == 3);
|
|
AddPedestal(360, 270, solution.Fifth, 4, check == 4);
|
|
|
|
AddButton(258, 370, 0xFA5, 0xFA7, 1, GumpButtonType.Reply, 0);
|
|
}
|
|
|
|
public override void OnResponse(NetState sender, RelayInfo info)
|
|
{
|
|
if (m_Chest.Deleted || info.ButtonID == 0 || !m_From.CheckAlive())
|
|
return;
|
|
|
|
if (m_From.IsPlayer() && (m_From.Map != m_Chest.Map || !m_From.InRange(m_Chest.GetWorldLocation(), 2)))
|
|
{
|
|
m_From.LocalOverheadMessage(MessageType.Regular, 0x3B2, 500446); // That is too far away.
|
|
return;
|
|
}
|
|
|
|
if (info.ButtonID == 1)
|
|
{
|
|
m_Chest.SubmitSolution(m_From, m_Solution);
|
|
}
|
|
else
|
|
{
|
|
if (info.Switches.Length == 0)
|
|
return;
|
|
|
|
int pedestal = info.Switches[0];
|
|
if (pedestal < 0 || pedestal >= m_Solution.Cylinders.Length)
|
|
return;
|
|
|
|
PuzzleChestCylinder cylinder;
|
|
switch ( info.ButtonID )
|
|
{
|
|
case 10:
|
|
cylinder = PuzzleChestCylinder.LightBlue;
|
|
break;
|
|
case 11:
|
|
cylinder = PuzzleChestCylinder.Blue;
|
|
break;
|
|
case 12:
|
|
cylinder = PuzzleChestCylinder.Green;
|
|
break;
|
|
case 13:
|
|
cylinder = PuzzleChestCylinder.Orange;
|
|
break;
|
|
case 14:
|
|
cylinder = PuzzleChestCylinder.Purple;
|
|
break;
|
|
case 15:
|
|
cylinder = PuzzleChestCylinder.Red;
|
|
break;
|
|
case 16:
|
|
cylinder = PuzzleChestCylinder.DarkBlue;
|
|
break;
|
|
case 17:
|
|
cylinder = PuzzleChestCylinder.Yellow;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
m_Solution.Cylinders[pedestal] = cylinder;
|
|
|
|
m_From.SendGump(new PuzzleGump(m_From, m_Chest, m_Solution, pedestal));
|
|
}
|
|
}
|
|
|
|
private void AddLeftCylinderButton(int x, int y, PuzzleChestCylinder cylinder, int buttonID)
|
|
{
|
|
AddBackground(x, y, 30, 30, 0x13EC);
|
|
AddCylinder(x - 7, y + 10, cylinder);
|
|
AddButton(x + 38, y + 9, 0x13A8, 0x4B9, buttonID, GumpButtonType.Reply, 0);
|
|
}
|
|
|
|
private void AddRightCylinderButton(int x, int y, PuzzleChestCylinder cylinder, int buttonID)
|
|
{
|
|
AddBackground(x, y, 30, 30, 0x13EC);
|
|
AddCylinder(x - 7, y + 10, cylinder);
|
|
AddButton(x - 26, y + 9, 0x13A8, 0x4B9, buttonID, GumpButtonType.Reply, 0);
|
|
}
|
|
|
|
private void AddPedestal(int x, int y, PuzzleChestCylinder cylinder, int switchID, bool initialState)
|
|
{
|
|
AddItem(x, y, 0xB10);
|
|
AddItem(x - 23, y + 12, 0xB12);
|
|
AddItem(x + 23, y + 12, 0xB13);
|
|
AddItem(x, y + 23, 0xB11);
|
|
|
|
if (cylinder != PuzzleChestCylinder.None)
|
|
{
|
|
AddItem(x, y + 2, 0x51A);
|
|
AddCylinder(x - 1, y + 19, cylinder);
|
|
}
|
|
else
|
|
{
|
|
AddItem(x, y + 2, 0x521);
|
|
}
|
|
|
|
AddRadio(x + 7, y + 65, 0x867, 0x86A, initialState, switchID);
|
|
}
|
|
|
|
private void AddCylinder(int x, int y, PuzzleChestCylinder cylinder)
|
|
{
|
|
if (cylinder != PuzzleChestCylinder.None)
|
|
AddItem(x, y, (int)cylinder);
|
|
else
|
|
AddItem(x + 9, y, (int)cylinder);
|
|
}
|
|
}
|
|
|
|
public class StatusGump : Gump
|
|
{
|
|
public StatusGump(int correctCylinders, int correctColors)
|
|
: base(50, 50)
|
|
{
|
|
AddBackground(15, 250, 305, 163, 0x53);
|
|
AddBackground(28, 265, 280, 133, 0xBB8);
|
|
|
|
AddHtmlLocalized(35, 271, 270, 24, 1018314, false, false); // Thou hast failed to solve the puzzle!
|
|
|
|
AddHtmlLocalized(35, 297, 250, 24, 1018315, false, false); // Correctly placed colors:
|
|
AddLabel(285, 297, 0x44, correctCylinders.ToString());
|
|
|
|
AddHtmlLocalized(35, 323, 250, 24, 1018316, false, false); // Used colors in wrong slots:
|
|
AddLabel(285, 323, 0x44, correctColors.ToString());
|
|
|
|
AddButton(152, 369, 0xFA5, 0xFA7, 0, GumpButtonType.Reply, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
[FlipableAttribute(0xE41, 0xE40)]
|
|
public class MetalGoldenPuzzleChest : PuzzleChest
|
|
{
|
|
[Constructable]
|
|
public MetalGoldenPuzzleChest()
|
|
: base(0xE41)
|
|
{
|
|
}
|
|
|
|
public MetalGoldenPuzzleChest(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();
|
|
}
|
|
}
|
|
|
|
[FlipableAttribute(0xE80, 0x9A8)]
|
|
public class StrongBoxPuzzle : PuzzleChest
|
|
{
|
|
[Constructable]
|
|
public StrongBoxPuzzle()
|
|
: base(0xE80)
|
|
{
|
|
}
|
|
|
|
public StrongBoxPuzzle(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();
|
|
}
|
|
}
|
|
}
|