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

Reorganizes Project (#41)

Browse source
This commit is contained in:
Kamron Batman 2019-08-02 18:13:40 -07:00 • committed by GitHub
parent 08bf44af9a
commit 3614a66aee
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3499 changed files with 79 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

33
Projects/Scripts/Items/Maps/BlankMap.cs Normal file
View file

@ -0,0 +1,33 @@
namespace Server.Items
{
public class BlankMap : MapItem
{
[Constructible]
public BlankMap()
{
}
public BlankMap(Serial serial) : base(serial)
{
}
public override void OnDoubleClick(Mobile from)
{
SendLocalizedMessageTo(from, 500208); // It appears to be blank.
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

49
Projects/Scripts/Items/Maps/CityMap.cs Normal file
View file

@ -0,0 +1,49 @@
namespace Server.Items
{
public class CityMap : MapItem
{
[Constructible]
public CityMap()
{
SetDisplay(0, 0, 5119, 4095, 400, 400);
}
public CityMap(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1015231; // city map
public override void CraftInit(Mobile from)
{
double skillValue = from.Skills.Cartography.Value;
int dist = 64 + (int)(skillValue * 4);
if (dist < 200)
dist = 200;
int size = 32 + (int)(skillValue * 2);
if (size < 200)
size = 200;
else if (size > 400)
size = 400;
SetDisplay(from.X - dist, from.Y - dist, from.X + dist, from.Y + dist, size, size);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

39
Projects/Scripts/Items/Maps/IndecipherableMap.cs Normal file
View file

@ -0,0 +1,39 @@
namespace Server.Items
{
public class IndecipherableMap : MapItem
{
[Constructible]
public IndecipherableMap()
{
if (Utility.RandomDouble() < 0.2)
Hue = 0x965;
else
Hue = 0x961;
}
public IndecipherableMap(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1070799; // indecipherable map
public override void OnDoubleClick(Mobile from)
{
from.SendLocalizedMessage(1070801); // You cannot decipher this ruined map.
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.WriteEncodedInt(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadEncodedInt();
}
}
}

39
Projects/Scripts/Items/Maps/LocalMap.cs Normal file
View file

@ -0,0 +1,39 @@
namespace Server.Items
{
public class LocalMap : MapItem
{
[Constructible]
public LocalMap()
{
SetDisplay(0, 0, 5119, 4095, 400, 400);
}
public LocalMap(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1015230; // local map
public override void CraftInit(Mobile from)
{
double skillValue = from.Skills.Cartography.Value;
int dist = 64 + (int)(skillValue * 2);
SetDisplay(from.X - dist, from.Y - dist, from.X + dist, from.Y + dist, 200, 200);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

379
Projects/Scripts/Items/Maps/MapItem.cs Normal file
View file

@ -0,0 +1,379 @@
using System;
using System.Collections.Generic;
using Server.Engines.Craft;
using Server.Network;
namespace Server.Items
{
[Flippable(0x14EB, 0x14EC)]
public class MapItem : Item, ICraftable
{
private const int MaxUserPins = 50;
private bool m_Editable;
[Constructible]
public MapItem() : base(0x14EC)
{
Weight = 1.0;
Width = 200;
Height = 200;
}
public MapItem(Serial serial) : base(serial)
{
}
[CommandProperty(AccessLevel.GameMaster)]
public bool Protected{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public Rectangle2D Bounds{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public int Width{ get; set; }
[CommandProperty(AccessLevel.GameMaster)]
public int Height{ get; set; }
public List<Point2D> Pins{ get; } = new List<Point2D>();
#region ICraftable Members
public int OnCraft(int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, BaseTool tool,
CraftItem craftItem, int resHue)
{
CraftInit(from);
return 1;
}
#endregion
public virtual void CraftInit(Mobile from)
{
}
public void SetDisplay(int x1, int y1, int x2, int y2, int w, int h)
{
Width = w;
Height = h;
if (x1 < 0)
x1 = 0;
if (y1 < 0)
y1 = 0;
if (x2 >= 5120)
x2 = 5119;
if (y2 >= 4096)
y2 = 4095;
Bounds = new Rectangle2D(x1, y1, x2 - x1, y2 - y1);
}
public override void OnDoubleClick(Mobile from)
{
if (from.InRange(GetWorldLocation(), 2))
DisplayTo(from);
else
from.SendLocalizedMessage(500446); // That is too far away.
}
public virtual void DisplayTo(Mobile from)
{
from.Send(new MapDetails(this));
from.Send(new MapDisplay(this));
for (int i = 0; i < Pins.Count; ++i)
from.Send(new MapAddPin(this, Pins[i]));
from.Send(new MapSetEditable(this, ValidateEdit(from)));
}
public virtual void OnAddPin(Mobile from, int x, int y)
{
if (!ValidateEdit(from))
return;
if (Pins.Count >= MaxUserPins)
return;
Validate(ref x, ref y);
AddPin(x, y);
}
public virtual void OnRemovePin(Mobile from, int number)
{
if (!ValidateEdit(from))
return;
RemovePin(number);
}
public virtual void OnChangePin(Mobile from, int number, int x, int y)
{
if (!ValidateEdit(from))
return;
Validate(ref x, ref y);
ChangePin(number, x, y);
}
public virtual void OnInsertPin(Mobile from, int number, int x, int y)
{
if (!ValidateEdit(from))
return;
if (Pins.Count >= MaxUserPins)
return;
Validate(ref x, ref y);
InsertPin(number, x, y);
}
public virtual void OnClearPins(Mobile from)
{
if (!ValidateEdit(from))
return;
ClearPins();
}
public virtual void OnToggleEditable(Mobile from)
{
if (Validate(from))
m_Editable = !m_Editable;
from.Send(new MapSetEditable(this, Validate(from) && m_Editable));
}
public virtual void Validate(ref int x, ref int y)
{
if (x < 0)
x = 0;
else if (x >= Width)
x = Width - 1;
if (y < 0)
y = 0;
else if (y >= Height)
y = Height - 1;
}
public virtual bool ValidateEdit(Mobile from)
{
return m_Editable && Validate(from);
}
public virtual bool Validate(Mobile from)
{
if (!from.CanSee(this) || from.Map != Map || !from.Alive || InSecureTrade)
return false;
if (from.AccessLevel >= AccessLevel.GameMaster)
return true;
if (!Movable || Protected || !from.InRange(GetWorldLocation(), 2))
return false;
return !(RootParent is Mobile && RootParent != from);
}
public void ConvertToWorld(int x, int y, out int worldX, out int worldY)
{
worldX = Bounds.Width * x / Width + Bounds.X;
worldY = Bounds.Height * y / Height + Bounds.Y;
}
public void ConvertToMap(int x, int y, out int mapX, out int mapY)
{
mapX = (x - Bounds.X) * Width / Bounds.Width;
mapY = (y - Bounds.Y) * Width / Bounds.Height;
}
public virtual void AddWorldPin(int x, int y)
{
ConvertToMap(x, y, out int mapX, out int mapY);
AddPin(mapX, mapY);
}
public virtual void AddPin(int x, int y)
{
Pins.Add(new Point2D(x, y));
}
public virtual void RemovePin(int index)
{
if (index > 0 && index < Pins.Count)
Pins.RemoveAt(index);
}
public virtual void InsertPin(int index, int x, int y)
{
if (index < 0 || index >= Pins.Count)
Pins.Add(new Point2D(x, y));
else
Pins.Insert(index, new Point2D(x, y));
}
public virtual void ChangePin(int index, int x, int y)
{
if (index >= 0 && index < Pins.Count)
Pins[index] = new Point2D(x, y);
}
public virtual void ClearPins()
{
Pins.Clear();
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
writer.Write(Bounds);
writer.Write(Width);
writer.Write(Height);
writer.Write(Protected);
writer.Write(Pins.Count);
for (int i = 0; i < Pins.Count; ++i)
writer.Write(Pins[i]);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 0:
{
Bounds = reader.ReadRect2D();
Width = reader.ReadInt();
Height = reader.ReadInt();
Protected = reader.ReadBool();
int count = reader.ReadInt();
for (int i = 0; i < count; i++)
Pins.Add(reader.ReadPoint2D());
break;
}
}
}
public static void Initialize()
{
PacketHandlers.Register(0x56, 11, true, OnMapCommand);
}
private static void OnMapCommand(NetState state, PacketReader pvSrc)
{
Mobile from = state.Mobile;
if (!(World.FindItem(pvSrc.ReadUInt32()) is MapItem map))
return;
int command = pvSrc.ReadByte();
int number = pvSrc.ReadByte();
int x = pvSrc.ReadInt16();
int y = pvSrc.ReadInt16();
switch (command)
{
case 1:
map.OnAddPin(from, x, y);
break;
case 2:
map.OnInsertPin(from, number, x, y);
break;
case 3:
map.OnChangePin(from, number, x, y);
break;
case 4:
map.OnRemovePin(from, number);
break;
case 5:
map.OnClearPins(from);
break;
case 6:
map.OnToggleEditable(from);
break;
}
}
private sealed class MapDetails : Packet
{
public MapDetails(MapItem map) : base(0x90, 19)
{
m_Stream.Write(map.Serial);
m_Stream.Write((short)0x139D);
m_Stream.Write((short)map.Bounds.Start.X);
m_Stream.Write((short)map.Bounds.Start.Y);
m_Stream.Write((short)map.Bounds.End.X);
m_Stream.Write((short)map.Bounds.End.Y);
m_Stream.Write((short)map.Width);
m_Stream.Write((short)map.Height);
}
}
/*
private sealed class MapDetailsNew : Packet
{
public MapDetailsNew( MapItem map ) : base ( 0xF5, 21 )
{
m_Stream.Write( (int) map.Serial );
m_Stream.Write( (short) 0x139D );
m_Stream.Write( (short) map.Bounds.Start.X );
m_Stream.Write( (short) map.Bounds.Start.Y );
m_Stream.Write( (short) map.Bounds.End.X );
m_Stream.Write( (short) map.Bounds.End.Y );
m_Stream.Write( (short) map.Width );
m_Stream.Write( (short) map.Height );
m_Stream.Write( (short) ( map.Facet == null ? 0 : map.Facet.MapID ) );
}
}
*/
private abstract class MapCommand : Packet
{
public MapCommand(MapItem map, int command, int number, int x, int y) : base(0x56, 11)
{
m_Stream.Write(map.Serial);
m_Stream.Write((byte)command);
m_Stream.Write((byte)number);
m_Stream.Write((short)x);
m_Stream.Write((short)y);
}
}
private sealed class MapDisplay : MapCommand
{
public MapDisplay(MapItem map) : base(map, 5, 0, 0, 0)
{
}
}
private sealed class MapAddPin : MapCommand
{
public MapAddPin(MapItem map, Point2D point) : base(map, 1, 0, point.X, point.Y)
{
}
}
private sealed class MapSetEditable : MapCommand
{
public MapSetEditable(MapItem map, bool editable) : base(map, 7, editable ? 1 : 0, 0, 0)
{
}
}
}
}

145
Projects/Scripts/Items/Maps/PresetMap.cs Normal file
View file

@ -0,0 +1,145 @@
namespace Server.Items
{
public class PresetMap : MapItem
{
private int m_LabelNumber;
[Constructible]
public PresetMap(PresetMapType type)
{
int v = (int)type;
if (v >= 0 && v < PresetMapEntry.Table.Length)
InitEntry(PresetMapEntry.Table[v]);
}
public PresetMap(PresetMapEntry entry)
{
InitEntry(entry);
}
public PresetMap(Serial serial) : base(serial)
{
}
public override int LabelNumber => m_LabelNumber == 0 ? base.LabelNumber : m_LabelNumber;
public void InitEntry(PresetMapEntry entry)
{
m_LabelNumber = entry.Name;
Width = entry.Width;
Height = entry.Height;
Bounds = entry.Bounds;
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
writer.Write(m_LabelNumber);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 0:
{
m_LabelNumber = reader.ReadInt();
break;
}
}
}
}
public class PresetMapEntry
{
public PresetMapEntry(int name, int width, int height, int xLeft, int yTop, int xRight, int yBottom)
{
Name = name;
Width = width;
Height = height;
Bounds = new Rectangle2D(xLeft, yTop, xRight - xLeft, yBottom - yTop);
}
public int Name{ get; }
public int Width{ get; }
public int Height{ get; }
public Rectangle2D Bounds{ get; }
public static PresetMapEntry[] Table{ get; } =
{
new PresetMapEntry(1041189, 200, 200, 1092, 1396, 1736, 1924), // map of Britain
new PresetMapEntry(1041203, 200, 200, 0256, 1792, 1736, 2560), // map of Britain to Skara Brae
new PresetMapEntry(1041192, 200, 200, 1024, 1280, 2304, 3072), // map of Britain to Trinsic
new PresetMapEntry(1041183, 200, 200, 2500, 1900, 3000, 2400), // map of Buccaneer's Den
new PresetMapEntry(1041198, 200, 200, 2560, 1792, 3840, 2560), // map of Buccaneer's Den to Magincia
new PresetMapEntry(1041194, 200, 200, 2560, 1792, 3840, 3072), // map of Buccaneer's Den to Ocllo
new PresetMapEntry(1041181, 200, 200, 1088, 3572, 1528, 4056), // map of Jhelom
new PresetMapEntry(1041186, 200, 200, 3530, 2022, 3818, 2298), // map of Magincia
new PresetMapEntry(1041199, 200, 200, 3328, 1792, 3840, 2304), // map of Magincia to Ocllo
new PresetMapEntry(1041182, 200, 200, 2360, 0356, 2706, 0702), // map of Minoc
new PresetMapEntry(1041190, 200, 200, 0000, 0256, 2304, 3072), // map of Minoc to Yew
new PresetMapEntry(1041191, 200, 200, 2467, 0572, 2878, 0746), // map of Minoc to Vesper
new PresetMapEntry(1041188, 200, 200, 4156, 0808, 4732, 1528), // map of Moonglow
new PresetMapEntry(1041201, 200, 200, 3328, 0768, 4864, 1536), // map of Moonglow to Nujelm
new PresetMapEntry(1041185, 200, 200, 3446, 1030, 3832, 1424), // map of Nujelm
new PresetMapEntry(1041197, 200, 200, 3328, 1024, 3840, 2304), // map of Nujelm to Magincia
new PresetMapEntry(1041187, 200, 200, 3582, 2456, 3770, 2742), // map of Ocllo
new PresetMapEntry(1041184, 200, 200, 2714, 3329, 3100, 3639), // map of Serpent's Hold
new PresetMapEntry(1041200, 200, 200, 2560, 2560, 3840, 3840), // map of Serpent's Hold to Ocllo
new PresetMapEntry(1041180, 200, 200, 0524, 2064, 0960, 2452), // map of Skara Brae
new PresetMapEntry(1041204, 200, 200, 0000, 0000, 5199, 4095), // map of The World
new PresetMapEntry(1041177, 200, 200, 1792, 2630, 2118, 2952), // map of Trinsic
new PresetMapEntry(1041193, 200, 200, 1792, 1792, 3072, 3072), // map of Trinsic to Buccaneer's Den
new PresetMapEntry(1041195, 200, 200, 0256, 1792, 2304, 4095), // map of Trinsic to Jhelom
new PresetMapEntry(1041178, 200, 200, 2636, 0592, 3064, 1012), // map of Vesper
new PresetMapEntry(1041196, 200, 200, 2636, 0592, 3840, 1536), // map of Vesper to Nujelm
new PresetMapEntry(1041179, 200, 200, 0236, 0741, 0766, 1269), // map of Yew
new PresetMapEntry(1041202, 200, 200, 0000, 0512, 1792, 2048) // map of Yew to Britain
};
}
public enum PresetMapType
{
Britain,
BritainToSkaraBrae,
BritainToTrinsic,
BucsDen,
BucsDenToMagincia,
BucsDenToOcllo,
Jhelom,
Magincia,
MaginciaToOcllo,
Minoc,
MinocToYew,
MinocToVesper,
Moonglow,
MoonglowToNujelm,
Nujelm,
NujelmToMagincia,
Ocllo,
SerpentsHold,
SerpentsHoldToOcllo,
SkaraBrae,
TheWorld,
Trinsic,
TrinsicToBucsDen,
TrinsicToJhelom,
Vesper,
VesperToNujelm,
Yew,
YewToBritain
}
}

49
Projects/Scripts/Items/Maps/SeaChart.cs Normal file
View file

@ -0,0 +1,49 @@
namespace Server.Items
{
public class SeaChart : MapItem
{
[Constructible]
public SeaChart()
{
SetDisplay(0, 0, 5119, 4095, 400, 400);
}
public SeaChart(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1015232; // sea chart
public override void CraftInit(Mobile from)
{
double skillValue = from.Skills.Cartography.Value;
int dist = 64 + (int)(skillValue * 10);
if (dist < 200)
dist = 200;
int size = 24 + (int)(skillValue * 3.3);
if (size < 200)
size = 200;
else if (size > 400)
size = 400;
SetDisplay(from.X - dist, from.Y - dist, from.X + dist, from.Y + dist, size, size);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}

979
Projects/Scripts/Items/Maps/TreasureMap.cs Normal file
View file

@ -0,0 +1,979 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Server.ContextMenus;
using Server.Engines.Harvest;
using Server.Mobiles;
using Server.Network;
using Server.Targeting;
namespace Server.Items
{
public class TreasureMap : MapItem
{
public const double LootChance = 0.01; // 1% chance to appear as loot
private static Point2D[] m_Locations;
private static Point2D[] m_HavenLocations;
private static Type[][] m_SpawnTypes =
{
new[] { typeof(HeadlessOne), typeof(Skeleton) },
new[] { typeof(Mongbat), typeof(Ratman), typeof(HeadlessOne), typeof(Skeleton), typeof(Zombie) },
new[] { typeof(OrcishMage), typeof(Gargoyle), typeof(Gazer), typeof(HellHound), typeof(EarthElemental) },
new[] { typeof(Lich), typeof(OgreLord), typeof(DreadSpider), typeof(AirElemental), typeof(FireElemental) },
new[] { typeof(DreadSpider), typeof(LichLord), typeof(Daemon), typeof(ElderGazer), typeof(OgreLord) },
new[] { typeof(LichLord), typeof(Daemon), typeof(ElderGazer), typeof(PoisonElemental), typeof(BloodElemental) },
new[] { typeof(AncientWyrm), typeof(Balron), typeof(BloodElemental), typeof(PoisonElemental), typeof(Titan) }
};
private bool m_Completed;
private Mobile m_CompletedBy;
private Mobile m_Decoder;
private int m_Level;
private Map m_Map;
[Constructible]
public TreasureMap(int level, Map map)
{
m_Level = level;
m_Map = map;
if (level == 0)
ChestLocation = GetRandomHavenLocation();
else
ChestLocation = GetRandomLocation();
Width = 300;
Height = 300;
int width = 600;
int height = 600;
int x1 = ChestLocation.X - Utility.RandomMinMax(width / 4, width / 4 * 3);
int y1 = ChestLocation.Y - Utility.RandomMinMax(height / 4, height / 4 * 3);
if (x1 < 0)
x1 = 0;
if (y1 < 0)
y1 = 0;
int x2 = x1 + width;
int y2 = y1 + height;
if (x2 >= 5120)
x2 = 5119;
if (y2 >= 4096)
y2 = 4095;
x1 = x2 - width;
y1 = y2 - height;
Bounds = new Rectangle2D(x1, y1, width, height);
Protected = true;
AddWorldPin(ChestLocation.X, ChestLocation.Y);
}
public TreasureMap(Serial serial) : base(serial)
{
}
[CommandProperty(AccessLevel.GameMaster)]
public int Level
{
get => m_Level;
set
{
m_Level = value;
InvalidateProperties();
}
}
[CommandProperty(AccessLevel.GameMaster)]
public bool Completed
{
get => m_Completed;
set
{
m_Completed = value;
InvalidateProperties();
}
}
[CommandProperty(AccessLevel.GameMaster)]
public Mobile CompletedBy
{
get => m_CompletedBy;
set
{
m_CompletedBy = value;
InvalidateProperties();
}
}
[CommandProperty(AccessLevel.GameMaster)]
public Mobile Decoder
{
get => m_Decoder;
set
{
m_Decoder = value;
InvalidateProperties();
}
}
[CommandProperty(AccessLevel.GameMaster)]
public Map ChestMap
{
get => m_Map;
set
{
m_Map = value;
InvalidateProperties();
}
}
[CommandProperty(AccessLevel.GameMaster)]
public Point2D ChestLocation{ get; set; }
public override int LabelNumber
{
get
{
if (m_Decoder != null)
{
if (m_Level == 6)
return 1063453;
return 1041516 + m_Level;
}
if (m_Level == 6)
return 1063452;
return 1041510 + m_Level;
}
}
public static Point2D GetRandomLocation()
{
if (m_Locations == null)
LoadLocations();
if (m_Locations.Length > 0)
return m_Locations[Utility.Random(m_Locations.Length)];
return Point2D.Zero;
}
public static Point2D GetRandomHavenLocation()
{
if (m_HavenLocations == null)
LoadLocations();
if (m_HavenLocations.Length > 0)
return m_HavenLocations[Utility.Random(m_HavenLocations.Length)];
return Point2D.Zero;
}
private static void LoadLocations()
{
string filePath = Path.Combine(Core.BaseDirectory, "Data/treasure.cfg");
List<Point2D> list = new List<Point2D>();
List<Point2D> havenList = new List<Point2D>();
if (File.Exists(filePath))
using (StreamReader ip = new StreamReader(filePath))
{
string line;
while ((line = ip.ReadLine()) != null)
try
{
string[] split = line.Split(' ');
int x = Convert.ToInt32(split[0]), y = Convert.ToInt32(split[1]);
Point2D loc = new Point2D(x, y);
list.Add(loc);
if (IsInHavenIsland(loc))
havenList.Add(loc);
}
catch
{
// ignored
}
}
m_Locations = list.ToArray();
m_HavenLocations = havenList.ToArray();
}
public static bool IsInHavenIsland(IPoint2D loc)
{
return loc.X >= 3314 && loc.X <= 3814 && loc.Y >= 2345 && loc.Y <= 3095;
}
public static BaseCreature Spawn(int level, Point3D p, bool guardian)
{
if (level >= 0 && level < m_SpawnTypes.Length)
{
BaseCreature bc;
try
{
bc = (BaseCreature)Activator.CreateInstance(
m_SpawnTypes[level][Utility.Random(m_SpawnTypes[level].Length)]);
}
catch
{
return null;
}
bc.Home = p;
bc.RangeHome = 5;
if (guardian && level == 0)
{
bc.Name = "a chest guardian";
bc.Hue = 0x835;
}
return bc;
}
return null;
}
public static BaseCreature Spawn(int level, Point3D p, Map map, Mobile target, bool guardian)
{
if (map == null)
return null;
BaseCreature c = Spawn(level, p, guardian);
if (c != null)
{
bool spawned = false;
for (int i = 0; !spawned && i < 10; ++i)
{
int x = p.X - 3 + Utility.Random(7);
int y = p.Y - 3 + Utility.Random(7);
if (map.CanSpawnMobile(x, y, p.Z))
{
c.MoveToWorld(new Point3D(x, y, p.Z), map);
spawned = true;
}
else
{
int z = map.GetAverageZ(x, y);
if (map.CanSpawnMobile(x, y, z))
{
c.MoveToWorld(new Point3D(x, y, z), map);
spawned = true;
}
}
}
if (!spawned)
{
c.Delete();
return null;
}
if (target != null)
c.Combatant = target;
return c;
}
return null;
}
public static bool HasDiggingTool(Mobile m)
{
return m.Backpack?.FindItemsByType<BaseHarvestTool>().Any(tool => tool.HarvestSystem == Mining.System) == true;
}
public void OnBeginDig(Mobile from)
{
if (m_Completed)
{
from.SendLocalizedMessage(503028); // The treasure for this map has already been found.
}
else if (m_Level == 0 && !CheckYoung(from))
{
from.SendLocalizedMessage(1046447); // Only a young player may use this treasure map.
}
/*
else if ( from != m_Decoder )
{
from.SendLocalizedMessage( 503016 ); // Only the person who decoded this map may actually dig up the treasure.
}
*/
else if (m_Decoder != from && !HasRequiredSkill(from))
{
from.SendLocalizedMessage(
503031); // You did not decode this map and have no clue where to look for the treasure.
}
else if (!from.CanBeginAction<TreasureMap>())
{
from.SendLocalizedMessage(503020); // You are already digging treasure.
}
else if (from.Map != m_Map)
{
from.SendLocalizedMessage(1010479); // You seem to be in the right place, but may be on the wrong facet!
}
else
{
from.SendLocalizedMessage(503033); // Where do you wish to dig?
from.Target = new DigTarget(this);
}
}
public override void OnDoubleClick(Mobile from)
{
if (!from.InRange(GetWorldLocation(), 2))
{
from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
return;
}
if (!m_Completed && m_Decoder == null)
Decode(from);
else
DisplayTo(from);
}
private bool CheckYoung(Mobile from)
{
if (from.AccessLevel >= AccessLevel.GameMaster)
return true;
if (from is PlayerMobile mobile && mobile.Young)
return true;
if (from == Decoder)
{
Level = 1;
from.SendLocalizedMessage(1046446); // This is now a level one treasure map.
return true;
}
return false;
}
private double GetMinSkillLevel()
{
switch (m_Level)
{
case 1: return -3.0;
case 2: return 41.0;
case 3: return 51.0;
case 4: return 61.0;
case 5: return 70.0;
case 6: return 70.0;
default: return 0.0;
}
}
private bool HasRequiredSkill(Mobile from)
{
return from.Skills.Cartography.Value >= GetMinSkillLevel();
}
public void Decode(Mobile from)
{
if (m_Completed || m_Decoder != null)
return;
if (m_Level == 0)
{
if (!CheckYoung(from))
{
from.SendLocalizedMessage(1046447); // Only a young player may use this treasure map.
return;
}
}
else
{
double minSkill = GetMinSkillLevel();
if (from.Skills.Cartography.Value < minSkill)
from.SendLocalizedMessage(503013); // The map is too difficult to attempt to decode.
double maxSkill = minSkill + 60.0;
if (!from.CheckSkill(SkillName.Cartography, minSkill, maxSkill))
{
from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 503018); // You fail to make anything of the map.
return;
}
}
from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 503019); // You successfully decode a treasure map!
Decoder = from;
if (Core.AOS)
LootType = LootType.Blessed;
DisplayTo(from);
}
public override void DisplayTo(Mobile from)
{
if (m_Completed)
{
SendLocalizedMessageTo(from, 503014); // This treasure hunt has already been completed.
}
else if (m_Level == 0 && !CheckYoung(from))
{
from.SendLocalizedMessage(1046447); // Only a young player may use this treasure map.
return;
}
else if (m_Decoder != from && !HasRequiredSkill(from))
{
from.SendLocalizedMessage(
503031); // You did not decode this map and have no clue where to look for the treasure.
return;
}
else
{
SendLocalizedMessageTo(from,
503017); // The treasure is marked by the red pin. Grab a shovel and go dig it up!
}
from.PlaySound(0x249);
base.DisplayTo(from);
}
public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
{
base.GetContextMenuEntries(from, list);
if (!m_Completed)
{
if (m_Decoder == null)
{
list.Add(new DecodeMapEntry(this));
}
else
{
bool digTool = HasDiggingTool(from);
list.Add(new OpenMapEntry(this));
list.Add(new DigEntry(this, digTool));
}
}
}
public override void GetProperties(ObjectPropertyList list)
{
base.GetProperties(list);
list.Add(m_Map == Map.Felucca ? 1041502 : 1041503); // for somewhere in Felucca : for somewhere in Trammel
if (m_Completed)
list.Add(1041507, m_CompletedBy == null ? "someone" : m_CompletedBy.Name); // completed by ~1_val~
}
public override void OnSingleClick(Mobile from)
{
if (m_Completed)
{
from.Send(new MessageLocalizedAffix(Serial, ItemID, MessageType.Label, 0x3B2, 3, 1048030, "",
AffixType.Append,
$" completed by {(m_CompletedBy == null ? "someone" : m_CompletedBy.Name)}", ""));
}
else if (m_Decoder != null)
{
if (m_Level == 6)
LabelTo(from, 1063453);
else
LabelTo(from, 1041516 + m_Level);
}
else
{
if (m_Level == 6)
LabelTo(from, 1041522, $"#{1063452}\t \t#{(m_Map == Map.Felucca ? 1041502 : 1041503)}");
else
LabelTo(from, 1041522, $"#{1041510 + m_Level}\t \t#{(m_Map == Map.Felucca ? 1041502 : 1041503)}");
}
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(1);
writer.Write(m_CompletedBy);
writer.Write(m_Level);
writer.Write(m_Completed);
writer.Write(m_Decoder);
writer.Write(m_Map);
writer.Write(ChestLocation);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
switch (version)
{
case 1:
{
m_CompletedBy = reader.ReadMobile();
goto case 0;
}
case 0:
{
m_Level = reader.ReadInt();
m_Completed = reader.ReadBool();
m_Decoder = reader.ReadMobile();
m_Map = reader.ReadMap();
ChestLocation = reader.ReadPoint2D();
if (version == 0 && m_Completed)
m_CompletedBy = m_Decoder;
break;
}
}
if (Core.AOS && m_Decoder != null && LootType == LootType.Regular)
LootType = LootType.Blessed;
}
private class DigTarget : Target
{
private TreasureMap m_Map;
public DigTarget(TreasureMap map) : base(6, true, TargetFlags.None)
{
m_Map = map;
}
protected override void OnTarget(Mobile from, object targeted)
{
if (m_Map.Deleted)
return;
Map map = m_Map.m_Map;
if (m_Map.m_Completed)
{
from.SendLocalizedMessage(503028); // The treasure for this map has already been found.
}
/*
else if ( from != m_Map.m_Decoder )
{
from.SendLocalizedMessage( 503016 ); // Only the person who decoded this map may actually dig up the treasure.
}
*/
else if (m_Map.m_Decoder != from && !m_Map.HasRequiredSkill(from))
{
from.SendLocalizedMessage(
503031); // You did not decode this map and have no clue where to look for the treasure.
}
else if (!from.CanBeginAction<TreasureMap>())
{
from.SendLocalizedMessage(503020); // You are already digging treasure.
}
else if (!HasDiggingTool(from))
{
from.SendMessage("You must have a digging tool to dig for treasure.");
}
else if (from.Map != map)
{
from.SendLocalizedMessage(1010479); // You seem to be in the right place, but may be on the wrong facet!
}
else
{
IPoint3D p = targeted as IPoint3D;
Point3D targ3D = (p as Item)?.GetWorldLocation() ?? new Point3D(p);
int maxRange;
double skillValue = from.Skills.Mining.Value;
if (skillValue >= 100.0)
maxRange = 4;
else if (skillValue >= 81.0)
maxRange = 3;
else if (skillValue >= 51.0)
maxRange = 2;
else
maxRange = 1;
Point2D loc = m_Map.ChestLocation;
int x = loc.X, y = loc.Y;
Point3D chest3D0 = new Point3D(loc, 0);
if (Utility.InRange(targ3D, chest3D0, maxRange))
{
if (from.Location.X == x && from.Location.Y == y)
{
from.SendLocalizedMessage(
503030); // The chest can't be dug up because you are standing on top of it.
}
else if (map != null)
{
int z = map.GetAverageZ(x, y);
if (!map.CanFit(x, y, z, 16, true))
from.SendLocalizedMessage(
503021); // You have found the treasure chest but something is keeping it from being dug up.
else if (from.BeginAction<TreasureMap>())
new DigTimer(from, m_Map, new Point3D(x, y, z), map).Start();
else
from.SendLocalizedMessage(503020); // You are already digging treasure.
}
}
else if (m_Map.Level > 0)
{
if (Utility.InRange(targ3D, chest3D0, 8)) // We're close, but not quite
from.SendLocalizedMessage(503032); // You dig and dig but no treasure seems to be here.
else
from.SendLocalizedMessage(503035); // You dig and dig but fail to find any treasure.
}
else
{
if (Utility.InRange(targ3D, chest3D0, 8)) // We're close, but not quite
{
from.SendAsciiMessage(0x44, "The treasure chest is very close!");
}
else
{
Direction dir = Utility.GetDirection(targ3D, chest3D0);
string sDir;
switch (dir)
{
case Direction.North:
sDir = "north";
break;
case Direction.Right:
sDir = "northeast";
break;
case Direction.East:
sDir = "east";
break;
case Direction.Down:
sDir = "southeast";
break;
case Direction.South:
sDir = "south";
break;
case Direction.Left:
sDir = "southwest";
break;
case Direction.West:
sDir = "west";
break;
default:
sDir = "northwest";
break;
}
from.SendAsciiMessage(0x44, "Try looking for the treasure chest more to the {0}.", sDir);
}
}
}
}
}
private class DigTimer : Timer
{
private TreasureMapChest m_Chest;
private int m_Count;
private TreasureChestDirt m_Dirt1;
private TreasureChestDirt m_Dirt2;
private Mobile m_From;
private long m_LastMoveTime;
private Point3D m_Location;
private Map m_Map;
private long m_NextActionTime;
private long m_NextSkillTime;
private long m_NextSpellTime;
private TreasureMap m_TreasureMap;
public DigTimer(Mobile from, TreasureMap treasureMap, Point3D location, Map map) : base(TimeSpan.Zero,
TimeSpan.FromSeconds(1.0))
{
m_From = from;
m_TreasureMap = treasureMap;
m_Location = location;
m_Map = map;
m_NextSkillTime = from.NextSkillTime;
m_NextSpellTime = from.NextSpellTime;
m_NextActionTime = from.NextActionTime;
m_LastMoveTime = from.LastMoveTime;
Priority = TimerPriority.TenMS;
}
private void Terminate()
{
Stop();
m_From.EndAction<TreasureMap>();
m_Chest?.Delete();
if (m_Dirt1 != null)
{
m_Dirt1.Delete();
m_Dirt2.Delete();
}
}
protected override void OnTick()
{
if (m_NextSkillTime != m_From.NextSkillTime || m_NextSpellTime != m_From.NextSpellTime ||
m_NextActionTime != m_From.NextActionTime)
{
Terminate();
return;
}
if (m_LastMoveTime != m_From.LastMoveTime)
{
m_From.SendLocalizedMessage(
503023); // You cannot move around while digging up treasure. You will need to start digging anew.
Terminate();
return;
}
int z = m_Chest != null ? m_Chest.Z + m_Chest.ItemData.Height : int.MinValue;
int height = 16;
if (z > m_Location.Z)
height -= z - m_Location.Z;
else
z = m_Location.Z;
if (!m_Map.CanFit(m_Location.X, m_Location.Y, z, height, true, true, false))
{
m_From.SendLocalizedMessage(
503024); // You stop digging because something is directly on top of the treasure chest.
Terminate();
return;
}
m_Count++;
m_From.RevealingAction();
m_From.Direction = m_From.GetDirectionTo(m_Location);
if (m_Count > 1 && m_Dirt1 == null)
{
m_Dirt1 = new TreasureChestDirt();
m_Dirt1.MoveToWorld(m_Location, m_Map);
m_Dirt2 = new TreasureChestDirt();
m_Dirt2.MoveToWorld(new Point3D(m_Location.X, m_Location.Y - 1, m_Location.Z), m_Map);
}
if (m_Count == 5)
{
m_Dirt1.Turn1();
}
else if (m_Count == 10)
{
m_Dirt1.Turn2();
m_Dirt2.Turn2();
}
else if (m_Count > 10)
{
if (m_Chest == null)
{
m_Chest = new TreasureMapChest(m_From, m_TreasureMap.Level, true);
m_Chest.MoveToWorld(new Point3D(m_Location.X, m_Location.Y, m_Location.Z - 15), m_Map);
}
else
{
m_Chest.Z++;
}
Effects.PlaySound(m_Chest, m_Map, 0x33B);
}
if (m_Chest?.Location.Z >= m_Location.Z)
{
Stop();
m_From.EndAction<TreasureMap>();
m_Chest.Temporary = false;
m_TreasureMap.Completed = true;
m_TreasureMap.CompletedBy = m_From;
int spawns;
switch (m_TreasureMap.Level)
{
case 0:
spawns = 3;
break;
case 1:
spawns = 0;
break;
default:
spawns = 4;
break;
}
for (int i = 0; i < spawns; ++i)
{
BaseCreature bc = Spawn(m_TreasureMap.Level, m_Chest.Location, m_Chest.Map, null, true);
if (bc != null)
m_Chest.Guardians.Add(bc);
}
}
else
{
if (m_From.Body.IsHuman && !m_From.Mounted)
m_From.Animate(11, 5, 1, true, false, 0);
new SoundTimer(m_From, 0x125 + m_Count % 2).Start();
}
}
private class SoundTimer : Timer
{
private Mobile m_From;
private int m_SoundID;
public SoundTimer(Mobile from, int soundID) : base(TimeSpan.FromSeconds(0.9))
{
m_From = from;
m_SoundID = soundID;
Priority = TimerPriority.TenMS;
}
protected override void OnTick()
{
m_From.PlaySound(m_SoundID);
}
}
}
private class DecodeMapEntry : ContextMenuEntry
{
private TreasureMap m_Map;
public DecodeMapEntry(TreasureMap map) : base(6147, 2)
{
m_Map = map;
}
public override void OnClick()
{
if (!m_Map.Deleted)
m_Map.Decode(Owner.From);
}
}
private class OpenMapEntry : ContextMenuEntry
{
private TreasureMap m_Map;
public OpenMapEntry(TreasureMap map) : base(6150, 2)
{
m_Map = map;
}
public override void OnClick()
{
if (!m_Map.Deleted)
m_Map.DisplayTo(Owner.From);
}
}
private class DigEntry : ContextMenuEntry
{
private TreasureMap m_Map;
public DigEntry(TreasureMap map, bool enabled) : base(6148, 2)
{
m_Map = map;
if (!enabled)
Flags |= CMEFlags.Disabled;
}
public override void OnClick()
{
if (m_Map.Deleted)
return;
Mobile from = Owner.From;
if (HasDiggingTool(from))
m_Map.OnBeginDig(from);
else
from.SendMessage("You must have a digging tool to dig for treasure.");
}
}
}
public class TreasureChestDirt : Item
{
public TreasureChestDirt() : base(0x912)
{
Movable = false;
Timer.DelayCall(TimeSpan.FromMinutes(2.0), Delete);
}
public TreasureChestDirt(Serial serial) : base(serial)
{
}
public void Turn1()
{
ItemID = 0x913;
}
public void Turn2()
{
ItemID = 0x914;
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.WriteEncodedInt(0); // version
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadEncodedInt();
Delete();
}
}
}

47
Projects/Scripts/Items/Maps/WorldMap.cs Normal file
View file

@ -0,0 +1,47 @@
namespace Server.Items
{
public class WorldMap : MapItem
{
[Constructible]
public WorldMap()
{
SetDisplay(0, 0, 5119, 4095, 400, 400);
}
public WorldMap(Serial serial) : base(serial)
{
}
public override int LabelNumber => 1015233; // world map
public override void CraftInit(Mobile from)
{
// Unlike the others, world map is not based on crafted location
double skillValue = from.Skills.Cartography.Value;
int x20 = (int)(skillValue * 20);
int size = 25 + (int)(skillValue * 6.6);
if (size < 200)
size = 200;
else if (size > 400)
size = 400;
SetDisplay(1344 - x20, 1600 - x20, 1472 + x20, 1728 + x20, size, size);
}
public override void Serialize(GenericWriter writer)
{
base.Serialize(writer);
writer.Write(0);
}
public override void Deserialize(GenericReader reader)
{
base.Deserialize(reader);
int version = reader.ReadInt();
}
}
}