395 lines
12 KiB
C#
395 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime.InteropServices;
|
|
using Server.Collections;
|
|
using Server.Logging;
|
|
using Server.Mobiles;
|
|
|
|
namespace Server.Engines.Virtues;
|
|
|
|
public enum VirtueLevel
|
|
{
|
|
None,
|
|
Seeker,
|
|
Follower,
|
|
Knight
|
|
}
|
|
|
|
[Flags]
|
|
public enum VirtueName
|
|
{
|
|
Humility,
|
|
Sacrifice,
|
|
Compassion,
|
|
Spirituality,
|
|
Valor,
|
|
Honor,
|
|
Justice,
|
|
Honesty
|
|
}
|
|
|
|
public class VirtueSystem : GenericPersistence
|
|
{
|
|
private static readonly ILogger logger = LogFactory.GetLogger(typeof(VirtueSystem));
|
|
|
|
private static readonly Dictionary<PlayerMobile, VirtueContext> _playerVirtues = new();
|
|
|
|
private static VirtueSystem _virtueSystemPersistence;
|
|
|
|
public static void Configure()
|
|
{
|
|
_virtueSystemPersistence = new VirtueSystem();
|
|
}
|
|
|
|
public VirtueSystem() : base("Virtues", 10)
|
|
{
|
|
}
|
|
|
|
private static void FixVirtue(Mobile m, int[] virtueValues)
|
|
{
|
|
if (m is not PlayerMobile pm)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var virtues = pm.Virtues;
|
|
for (var i = 0; i < virtueValues.Length; i++)
|
|
{
|
|
var val = virtueValues[i];
|
|
if (val > 0)
|
|
{
|
|
virtues.SetValue(i, val);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Initialize()
|
|
{
|
|
var migrations = Mobile.VirtueMigrations;
|
|
if (migrations?.Count > 0)
|
|
{
|
|
foreach (var (m, values) in migrations)
|
|
{
|
|
FixVirtue(m, values);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Serialize(IGenericWriter writer)
|
|
{
|
|
writer.WriteEncodedInt(0); // version
|
|
|
|
writer.WriteEncodedInt(_playerVirtues.Count);
|
|
foreach (var (pm, virtues) in _playerVirtues)
|
|
{
|
|
writer.Write(pm);
|
|
virtues.Serialize(writer);
|
|
}
|
|
}
|
|
|
|
public override void Deserialize(IGenericReader reader)
|
|
{
|
|
reader.ReadEncodedInt(); // version
|
|
|
|
var contextCount = reader.ReadEncodedInt();
|
|
for (var i = 0; i < contextCount; i++)
|
|
{
|
|
var player = reader.ReadEntity<PlayerMobile>();
|
|
var virtues = new VirtueContext();
|
|
virtues.Deserialize(reader);
|
|
|
|
if (virtues.IsUsed())
|
|
{
|
|
_playerVirtues.Add(player, virtues);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static VirtueContext GetVirtues(PlayerMobile from) =>
|
|
from != null && _playerVirtues.TryGetValue(from, out var context) ? context : null;
|
|
|
|
public static VirtueContext GetOrCreateVirtues(PlayerMobile from)
|
|
{
|
|
if (from == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
ref VirtueContext context = ref CollectionsMarshal.GetValueRefOrAddDefault(_playerVirtues, from, out bool exists);
|
|
if (!exists)
|
|
{
|
|
context = new VirtueContext();
|
|
}
|
|
|
|
return context;
|
|
}
|
|
|
|
public static bool IsHighestPath(PlayerMobile from, VirtueName virtue) =>
|
|
GetVirtues(from)?.GetValue((int)virtue) >= GetMaxAmount(virtue);
|
|
|
|
public static VirtueLevel GetLevel(Mobile from, VirtueName virtue)
|
|
{
|
|
var v = GetVirtues(from as PlayerMobile)?.GetValue((int)virtue) ?? 0;
|
|
int vl;
|
|
|
|
if (v < 4000)
|
|
{
|
|
vl = 0;
|
|
}
|
|
else if (v >= GetMaxAmount(virtue))
|
|
{
|
|
vl = 3;
|
|
}
|
|
else
|
|
{
|
|
vl = (v + 9999) / 10000;
|
|
}
|
|
|
|
return (VirtueLevel)vl;
|
|
}
|
|
|
|
public static string GetName(VirtueName virtue) =>
|
|
virtue switch
|
|
{
|
|
VirtueName.Humility => "Humility",
|
|
VirtueName.Sacrifice => "Sacrifice",
|
|
VirtueName.Compassion => "Compassion",
|
|
VirtueName.Spirituality => "Spirituality",
|
|
VirtueName.Valor => "Valor",
|
|
VirtueName.Honor => "Honor",
|
|
VirtueName.Justice => "Justice",
|
|
VirtueName.Honesty => "Honesty",
|
|
_ => ""
|
|
};
|
|
|
|
public static string GetLowerCaseName(VirtueName virtue) =>
|
|
virtue switch
|
|
{
|
|
VirtueName.Humility => "humility",
|
|
VirtueName.Sacrifice => "sacrifice",
|
|
VirtueName.Compassion => "compassion",
|
|
VirtueName.Spirituality => "spirituality",
|
|
VirtueName.Valor => "valor",
|
|
VirtueName.Honor => "honor",
|
|
VirtueName.Justice => "justice",
|
|
VirtueName.Honesty => "honesty",
|
|
_ => ""
|
|
};
|
|
|
|
public static int GetMaxAmount(VirtueName virtue) =>
|
|
virtue switch
|
|
{
|
|
VirtueName.Honor => 20000,
|
|
VirtueName.Sacrifice => 22000,
|
|
_ => 21000
|
|
};
|
|
|
|
public static int GetGainedLocalizedMessage(VirtueName virtue) =>
|
|
virtue switch
|
|
{
|
|
VirtueName.Sacrifice => 1054160, // You have gained in sacrifice.
|
|
VirtueName.Compassion => 1053002, // You have gained in compassion.
|
|
VirtueName.Spirituality => 1155832, // You have gained in Spirituality.
|
|
VirtueName.Valor => 1054030, // You have gained in Valor!
|
|
VirtueName.Honor => 1063225, // You have gained in Honor.
|
|
VirtueName.Justice => 1049363, // You have gained in Justice.
|
|
VirtueName.Humility => 1052070, // You have gained in Humility.
|
|
_ => 0
|
|
};
|
|
|
|
public static int GetGainedAPathLocalizedMessage(VirtueName virtue) =>
|
|
virtue switch
|
|
{
|
|
VirtueName.Sacrifice => 1052008, // You have gained a path in Sacrifice!
|
|
VirtueName.Spirituality => 1155833, // "You have gained a path in Spirituality!" (Why are there quotes?)
|
|
VirtueName.Valor => 1054032, // You have gained a path in Valor!
|
|
VirtueName.Honor => 1063226, // You have gained a path in Honor!
|
|
VirtueName.Justice => 1049367, // You have gained a path in Justice!
|
|
VirtueName.Humility => 1155811, // You have gained a path in Humility!
|
|
_ => 0
|
|
};
|
|
|
|
public static int GetHightestPathLocalizedMessage(VirtueName virtue) =>
|
|
virtue switch
|
|
{
|
|
VirtueName.Compassion => 1053003, // You have achieved the highest path of compassion and can no longer gain any further.
|
|
VirtueName.Spirituality => 1155831, // You cannot gain more Spirituality.
|
|
VirtueName.Valor => 1054031, // You have achieved the highest path in Valor and can no longer gain any further.
|
|
VirtueName.Honor => 1063228, // You cannot gain more Honor.
|
|
VirtueName.Justice => 1049534, // You cannot gain more Justice.
|
|
VirtueName.Humility => 1155808, // You cannot gain more Humility.
|
|
VirtueName.Honesty => 1153771, // You have achieved the highest path in Honesty and can no longer gain any further.
|
|
_ => 1052050, // You have achieved the highest path in this virtue.
|
|
};
|
|
|
|
public static bool Award(PlayerMobile from, VirtueName virtue, int amount, ref bool gainedPath)
|
|
{
|
|
var virtues = from.Virtues;
|
|
|
|
var current = virtues.GetValue((int)virtue);
|
|
|
|
var maxAmount = GetMaxAmount(virtue);
|
|
|
|
if (current >= maxAmount)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (current + amount >= maxAmount)
|
|
{
|
|
amount = maxAmount - current;
|
|
}
|
|
|
|
var oldLevel = GetLevel(from, virtue);
|
|
|
|
virtues.SetValue((int)virtue, current + amount);
|
|
|
|
gainedPath = GetLevel(from, virtue) != oldLevel;
|
|
|
|
return true;
|
|
}
|
|
|
|
public static bool Atrophy(PlayerMobile from, VirtueName virtue, int amount = 1)
|
|
{
|
|
var virtues = GetVirtues(from);
|
|
if (virtues == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var current = virtues.GetValue((int)virtue);
|
|
|
|
if (current - amount >= 0)
|
|
{
|
|
virtues.SetValue((int)virtue, current - amount);
|
|
}
|
|
else
|
|
{
|
|
virtues.SetValue((int)virtue, 0);
|
|
}
|
|
|
|
return current > 0;
|
|
}
|
|
|
|
public static bool IsSeeker(PlayerMobile from, VirtueName virtue) => GetLevel(from, virtue) >= VirtueLevel.Seeker;
|
|
|
|
public static bool IsFollower(PlayerMobile from, VirtueName virtue) => GetLevel(from, virtue) >= VirtueLevel.Follower;
|
|
|
|
public static bool IsKnight(PlayerMobile from, VirtueName virtue) => GetLevel(from, virtue) >= VirtueLevel.Knight;
|
|
|
|
public static void AwardVirtue(PlayerMobile pm, VirtueName virtue, int amount)
|
|
{
|
|
var virtues = GetOrCreateVirtues(pm);
|
|
if (virtue == VirtueName.Compassion)
|
|
{
|
|
if (virtues.CompassionGains > 0 && Core.Now > virtues.NextCompassionDay)
|
|
{
|
|
virtues.NextCompassionDay = DateTime.MinValue;
|
|
virtues.CompassionGains = 0;
|
|
}
|
|
|
|
if (virtues.CompassionGains >= 5)
|
|
{
|
|
pm.SendLocalizedMessage(1053004); // You must wait about a day before you can gain in compassion again.
|
|
return;
|
|
}
|
|
}
|
|
|
|
var gainedPath = false;
|
|
var virtueName = GetName(virtue);
|
|
|
|
if (Award(pm, virtue, amount, ref gainedPath))
|
|
{
|
|
if (gainedPath)
|
|
{
|
|
var gainedPathMessage = GetGainedAPathLocalizedMessage(virtue);
|
|
if (gainedPathMessage != 0)
|
|
{
|
|
pm.SendLocalizedMessage(gainedPathMessage);
|
|
}
|
|
else
|
|
{
|
|
pm.SendMessage($"You have gained a path in {virtueName}!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var gainMessage = GetGainedLocalizedMessage(virtue);
|
|
if (gainMessage != 0)
|
|
{
|
|
pm.SendLocalizedMessage(gainMessage);
|
|
}
|
|
else
|
|
{
|
|
pm.SendMessage($"You have gained in {virtueName}.");
|
|
}
|
|
}
|
|
|
|
if (virtue == VirtueName.Compassion)
|
|
{
|
|
virtues.NextCompassionDay = Core.Now + TimeSpan.FromDays(1.0);
|
|
|
|
if (++virtues.CompassionGains >= 5)
|
|
{
|
|
// You must wait about a day before you can gain in compassion again.
|
|
pm.SendLocalizedMessage(1053004);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pm.SendLocalizedMessage(GetHightestPathLocalizedMessage(virtue));
|
|
}
|
|
}
|
|
|
|
public static void CheckAtrophies(PlayerMobile pm)
|
|
{
|
|
SacrificeVirtue.CheckAtrophy(pm);
|
|
JusticeVirtue.CheckAtrophy(pm);
|
|
CompassionVirtue.CheckAtrophy(pm);
|
|
ValorVirtue.CheckAtrophy(pm);
|
|
}
|
|
|
|
private class VirtueTimer : Timer
|
|
{
|
|
public VirtueTimer() : base(TimeSpan.FromMinutes(5.0), TimeSpan.FromMinutes(5.0))
|
|
{
|
|
}
|
|
|
|
public static void Initialize()
|
|
{
|
|
new VirtueTimer().Start();
|
|
}
|
|
|
|
protected override void OnTick()
|
|
{
|
|
if (_playerVirtues.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
using var queue = PooledRefQueue<Mobile>.Create();
|
|
|
|
// This is not particularly efficient. If it gets too slow, then use a different architecture.
|
|
foreach (var (player, virtues) in _playerVirtues)
|
|
{
|
|
CheckAtrophies(player);
|
|
|
|
if (!virtues.IsUsed())
|
|
{
|
|
queue.Enqueue(player);
|
|
}
|
|
}
|
|
|
|
while (queue.Count > 0)
|
|
{
|
|
_playerVirtues.Remove((PlayerMobile)queue.Dequeue());
|
|
}
|
|
}
|
|
|
|
~VirtueTimer()
|
|
{
|
|
VirtueSystem.logger.Error($"{nameof(VirtueTimer)} is no longer running!");
|
|
}
|
|
}
|
|
}
|