1325 lines
38 KiB
C#
1325 lines
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Server.Accounting;
|
|
using Server.Commands.Generic;
|
|
using Server.Engines.ConPVP;
|
|
using Server.Ethics;
|
|
using Server.Guilds;
|
|
using Server.Items;
|
|
using Server.Mobiles;
|
|
using Server.Prompts;
|
|
using Server.Targeting;
|
|
|
|
namespace Server.Factions
|
|
{
|
|
[CustomEnum(new[] { "Minax", "Council of Mages", "True Britannians", "Shadowlords" })]
|
|
public abstract class Faction : IComparable<Faction>
|
|
{
|
|
public const int StabilityFactor = 300; // 300% greater (3 times) than smallest faction
|
|
public const int StabilityActivation = 200; // Stability code goes into effect when largest faction has > 200 people
|
|
|
|
public static readonly TimeSpan LeavePeriod = TimeSpan.FromDays(3.0);
|
|
|
|
public static readonly Map Facet = Map.Felucca;
|
|
|
|
private FactionDefinition m_Definition;
|
|
public int ZeroRankOffset;
|
|
|
|
public Faction() => State = new FactionState(this);
|
|
|
|
public StrongholdRegion StrongholdRegion { get; set; }
|
|
|
|
public FactionDefinition Definition
|
|
{
|
|
get => m_Definition;
|
|
set
|
|
{
|
|
m_Definition = value;
|
|
StrongholdRegion = new StrongholdRegion(this);
|
|
}
|
|
}
|
|
|
|
public FactionState State { get; set; }
|
|
|
|
public Election Election
|
|
{
|
|
get => State.Election;
|
|
set => State.Election = value;
|
|
}
|
|
|
|
public Mobile Commander
|
|
{
|
|
get => State.Commander;
|
|
set => State.Commander = value;
|
|
}
|
|
|
|
public int Tithe
|
|
{
|
|
get => State.Tithe;
|
|
set => State.Tithe = value;
|
|
}
|
|
|
|
public int Silver
|
|
{
|
|
get => State.Silver;
|
|
set => State.Silver = value;
|
|
}
|
|
|
|
public List<PlayerState> Members
|
|
{
|
|
get => State.Members;
|
|
set => State.Members = value;
|
|
}
|
|
|
|
public bool FactionMessageReady => State.FactionMessageReady;
|
|
|
|
public virtual int MaximumTraps => 15;
|
|
|
|
public List<BaseFactionTrap> Traps
|
|
{
|
|
get => State.Traps;
|
|
set => State.Traps = value;
|
|
}
|
|
|
|
public static List<Faction> Factions => Reflector.Factions;
|
|
|
|
public int CompareTo(Faction f) => m_Definition.Sort - (f?.m_Definition.Sort ?? 0);
|
|
|
|
public void Broadcast(string text)
|
|
{
|
|
Broadcast(0x3B2, text);
|
|
}
|
|
|
|
public void Broadcast(int hue, string text)
|
|
{
|
|
List<PlayerState> members = Members;
|
|
|
|
for (int i = 0; i < members.Count; ++i)
|
|
members[i].Mobile.SendMessage(hue, text);
|
|
}
|
|
|
|
public void Broadcast(int number)
|
|
{
|
|
List<PlayerState> members = Members;
|
|
|
|
for (int i = 0; i < members.Count; ++i)
|
|
members[i].Mobile.SendLocalizedMessage(number);
|
|
}
|
|
|
|
public void Broadcast(string format, params object[] args)
|
|
{
|
|
Broadcast(string.Format(format, args));
|
|
}
|
|
|
|
public void Broadcast(int hue, string format, params object[] args)
|
|
{
|
|
Broadcast(hue, string.Format(format, args));
|
|
}
|
|
|
|
public void BeginBroadcast(Mobile from)
|
|
{
|
|
from.SendLocalizedMessage(1010265); // Enter Faction Message
|
|
from.Prompt = new BroadcastPrompt(this);
|
|
}
|
|
|
|
public void EndBroadcast(Mobile from, string text)
|
|
{
|
|
if (from.AccessLevel == AccessLevel.Player)
|
|
State.RegisterBroadcast();
|
|
|
|
Broadcast(Definition.HueBroadcast, "{0} [Commander] {1} : {2}", from.Name, Definition.FriendlyName, text);
|
|
}
|
|
|
|
public static void HandleAtrophy()
|
|
{
|
|
foreach (Faction f in Factions)
|
|
if (!f.State.IsAtrophyReady)
|
|
return;
|
|
|
|
List<PlayerState> activePlayers = new List<PlayerState>();
|
|
|
|
foreach (Faction f in Factions)
|
|
foreach (PlayerState ps in f.Members)
|
|
if (ps.KillPoints > 0 && ps.IsActive)
|
|
activePlayers.Add(ps);
|
|
|
|
int distrib = 0;
|
|
|
|
foreach (Faction f in Factions)
|
|
distrib += f.State.CheckAtrophy();
|
|
|
|
if (activePlayers.Count == 0)
|
|
return;
|
|
|
|
for (int i = 0; i < distrib; ++i)
|
|
activePlayers[Utility.Random(activePlayers.Count)].KillPoints++;
|
|
}
|
|
|
|
public static void DistributePoints(int distrib)
|
|
{
|
|
List<PlayerState> activePlayers = new List<PlayerState>();
|
|
|
|
foreach (Faction f in Factions)
|
|
foreach (PlayerState ps in f.Members)
|
|
if (ps.KillPoints > 0 && ps.IsActive)
|
|
activePlayers.Add(ps);
|
|
|
|
if (activePlayers.Count > 0)
|
|
for (int i = 0; i < distrib; ++i)
|
|
activePlayers[Utility.Random(activePlayers.Count)].KillPoints++;
|
|
}
|
|
|
|
public void BeginHonorLeadership(Mobile from)
|
|
{
|
|
from.SendLocalizedMessage(502090); // Click on the player whom you wish to honor.
|
|
from.BeginTarget(12, false, TargetFlags.None, HonorLeadership_OnTarget);
|
|
}
|
|
|
|
public void HonorLeadership_OnTarget(Mobile from, object obj)
|
|
{
|
|
if (obj is Mobile recv)
|
|
{
|
|
PlayerState giveState = PlayerState.Find(from);
|
|
PlayerState recvState = PlayerState.Find(recv);
|
|
|
|
if (giveState == null)
|
|
return;
|
|
|
|
if (recvState == null || recvState.Faction != giveState.Faction)
|
|
{
|
|
from.SendLocalizedMessage(1042497); // Only faction mates can be honored this way.
|
|
}
|
|
else if (giveState.KillPoints < 5)
|
|
{
|
|
from.SendLocalizedMessage(1042499); // You must have at least five kill points to honor them.
|
|
}
|
|
else
|
|
{
|
|
recvState.LastHonorTime = DateTime.UtcNow;
|
|
giveState.KillPoints -= 5;
|
|
recvState.KillPoints += 4;
|
|
|
|
// TODO: Confirm no message sent to giver
|
|
recv.SendLocalizedMessage(1042500); // You have been honored with four kill points.
|
|
}
|
|
}
|
|
else
|
|
{
|
|
from.SendLocalizedMessage(1042496); // You may only honor another player.
|
|
}
|
|
}
|
|
|
|
public virtual void AddMember(Mobile mob)
|
|
{
|
|
Members.Insert(ZeroRankOffset, new PlayerState(mob, this, Members));
|
|
|
|
mob.AddToBackpack(FactionItem.Imbue(new Robe(), this, false, Definition.HuePrimary));
|
|
mob.SendLocalizedMessage(1010374); // You have been granted a robe which signifies your faction
|
|
|
|
mob.InvalidateProperties();
|
|
mob.Delta(MobileDelta.Noto);
|
|
|
|
mob.FixedEffect(0x373A, 10, 30);
|
|
mob.PlaySound(0x209);
|
|
}
|
|
|
|
public static bool IsNearType(Mobile mob, Type type, int range)
|
|
{
|
|
bool mobs = type.IsSubclassOf(typeof(Mobile));
|
|
bool items = type.IsSubclassOf(typeof(Item));
|
|
|
|
if (!(items || mobs))
|
|
return false;
|
|
|
|
IPooledEnumerable<IEntity> eable = mob.Map.GetObjectsInRange(mob.Location, range, items, mobs);
|
|
bool isInstance = eable.Any(type.IsInstanceOfType);
|
|
eable.Free();
|
|
|
|
return isInstance;
|
|
}
|
|
|
|
public static bool IsNearType(Mobile mob, Type[] types, int range)
|
|
{
|
|
IPooledEnumerable<IEntity> eable = mob.GetObjectsInRange(range);
|
|
bool found = eable.Any(obj => types.Any(t => t.IsInstanceOfType(obj)));
|
|
eable.Free();
|
|
return found;
|
|
}
|
|
|
|
public void RemovePlayerState(PlayerState pl)
|
|
{
|
|
if (pl == null || !Members.Contains(pl))
|
|
return;
|
|
|
|
int killPoints = pl.KillPoints;
|
|
|
|
if (pl.RankIndex != -1)
|
|
{
|
|
while (pl.RankIndex + 1 < ZeroRankOffset)
|
|
{
|
|
PlayerState pNext = Members[pl.RankIndex + 1];
|
|
Members[pl.RankIndex + 1] = pl;
|
|
Members[pl.RankIndex] = pNext;
|
|
pl.RankIndex++;
|
|
pNext.RankIndex--;
|
|
}
|
|
|
|
ZeroRankOffset--;
|
|
}
|
|
|
|
Members.Remove(pl);
|
|
|
|
PlayerMobile pm = (PlayerMobile)pl.Mobile;
|
|
if (pm == null)
|
|
return;
|
|
|
|
Mobile mob = pl.Mobile;
|
|
if (pm.FactionPlayerState == pl)
|
|
{
|
|
pm.FactionPlayerState = null;
|
|
|
|
mob.InvalidateProperties();
|
|
mob.Delta(MobileDelta.Noto);
|
|
|
|
if (Election.IsCandidate(mob))
|
|
Election.RemoveCandidate(mob);
|
|
|
|
if (pl.Finance != null)
|
|
pl.Finance.Finance = null;
|
|
|
|
if (pl.Sheriff != null)
|
|
pl.Sheriff.Sheriff = null;
|
|
|
|
Election.RemoveVoter(mob);
|
|
|
|
if (Commander == mob)
|
|
Commander = null;
|
|
|
|
pm.ValidateEquipment();
|
|
}
|
|
|
|
if (killPoints > 0)
|
|
DistributePoints(killPoints);
|
|
}
|
|
|
|
public void RemoveMember(Mobile mob)
|
|
{
|
|
PlayerState pl = PlayerState.Find(mob);
|
|
|
|
if (pl == null || !Members.Contains(pl))
|
|
return;
|
|
|
|
int killPoints = pl.KillPoints;
|
|
|
|
// Ordinarily, through normal faction removal, this will never find any sigils.
|
|
// Only with a leave delay less than the ReturnPeriod or a Faction Kick/Ban, will this ever do anything
|
|
mob.Backpack?.FindItemsByType<Sigil>().ForEach(sigil => sigil.ReturnHome());
|
|
|
|
if (pl.RankIndex != -1)
|
|
{
|
|
while (pl.RankIndex + 1 < ZeroRankOffset)
|
|
{
|
|
PlayerState pNext = Members[pl.RankIndex + 1];
|
|
Members[pl.RankIndex + 1] = pl;
|
|
Members[pl.RankIndex] = pNext;
|
|
pl.RankIndex++;
|
|
pNext.RankIndex--;
|
|
}
|
|
|
|
ZeroRankOffset--;
|
|
}
|
|
|
|
Members.Remove(pl);
|
|
|
|
if (mob is PlayerMobile mobile)
|
|
mobile.FactionPlayerState = null;
|
|
|
|
mob.InvalidateProperties();
|
|
mob.Delta(MobileDelta.Noto);
|
|
|
|
if (Election.IsCandidate(mob))
|
|
Election.RemoveCandidate(mob);
|
|
|
|
Election.RemoveVoter(mob);
|
|
|
|
if (pl.Finance != null)
|
|
pl.Finance.Finance = null;
|
|
|
|
if (pl.Sheriff != null)
|
|
pl.Sheriff.Sheriff = null;
|
|
|
|
if (Commander == mob)
|
|
Commander = null;
|
|
|
|
if (mob is PlayerMobile playerMobile)
|
|
playerMobile.ValidateEquipment();
|
|
|
|
if (killPoints > 0)
|
|
DistributePoints(killPoints);
|
|
}
|
|
|
|
public void JoinGuilded(PlayerMobile mob, Guild guild)
|
|
{
|
|
if (mob.Young)
|
|
{
|
|
guild.RemoveMember(mob);
|
|
mob.SendLocalizedMessage(
|
|
1042283); // You have been kicked out of your guild! Young players may not remain in a guild which is allied with a faction.
|
|
}
|
|
else if (AlreadyHasCharInFaction(mob))
|
|
{
|
|
guild.RemoveMember(mob);
|
|
mob.SendLocalizedMessage(1005281); // You have been kicked out of your guild due to factional overlap
|
|
}
|
|
else if (IsFactionBanned(mob))
|
|
{
|
|
guild.RemoveMember(mob);
|
|
mob.SendLocalizedMessage(1005052); // You are currently banned from the faction system
|
|
}
|
|
else
|
|
{
|
|
AddMember(mob);
|
|
mob.SendLocalizedMessage(1042756, true, $" {m_Definition.FriendlyName}"); // You are now joining a faction:
|
|
}
|
|
}
|
|
|
|
public void JoinAlone(Mobile mob)
|
|
{
|
|
AddMember(mob);
|
|
mob.SendLocalizedMessage(1005058); // You have joined the faction
|
|
}
|
|
|
|
private bool AlreadyHasCharInFaction(Mobile mob)
|
|
{
|
|
if (mob.Account is Account acct)
|
|
for (int i = 0; i < acct.Length; ++i)
|
|
{
|
|
Mobile c = acct[i];
|
|
|
|
if (Find(c) != null)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool IsFactionBanned(Mobile mob)
|
|
{
|
|
if (!(mob.Account is Account acct))
|
|
return false;
|
|
|
|
return acct.GetTag("FactionBanned") != null;
|
|
}
|
|
|
|
public void OnJoinAccepted(Mobile mob)
|
|
{
|
|
if (!(mob is PlayerMobile pm))
|
|
return; // sanity
|
|
|
|
PlayerState pl = PlayerState.Find(pm);
|
|
|
|
if (pm.Young)
|
|
{
|
|
pm.SendLocalizedMessage(1010104); // You cannot join a faction as a young player
|
|
}
|
|
else if (pl?.IsLeaving == true)
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1005051); // You cannot use the faction stone until you have finished quitting your current faction
|
|
}
|
|
else if (AlreadyHasCharInFaction(pm))
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1005059); // You cannot join a faction because you already declared your allegiance with another character
|
|
}
|
|
else if (IsFactionBanned(mob))
|
|
{
|
|
pm.SendLocalizedMessage(1005052); // You are currently banned from the faction system
|
|
}
|
|
else if (pm.Guild != null)
|
|
{
|
|
Guild guild = pm.Guild as Guild;
|
|
|
|
if (guild?.Leader != pm)
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1005057); // You cannot join a faction because you are in a guild and not the guildmaster
|
|
}
|
|
else if (guild.Type != GuildType.Regular)
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1042161); // You cannot join a faction because your guild is an Order or Chaos type.
|
|
}
|
|
else if (!Guild.NewGuildSystem && guild.Enemies?.Count > 0) // CAN join w/wars in new system
|
|
{
|
|
pm.SendLocalizedMessage(1005056); // You cannot join a faction with active Wars
|
|
}
|
|
else if (Guild.NewGuildSystem && guild.Alliance != null)
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1080454); // Your guild cannot join a faction while in alliance with non-factioned guilds.
|
|
}
|
|
else if (!CanHandleInflux(guild.Members.Count))
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1018031); // In the interest of faction stability, this faction declines to accept new members for now.
|
|
}
|
|
else
|
|
{
|
|
List<Mobile> members = new List<Mobile>(guild.Members);
|
|
|
|
for (int i = 0; i < members.Count; ++i)
|
|
{
|
|
if (!(members[i] is PlayerMobile member))
|
|
continue;
|
|
|
|
JoinGuilded(member, guild);
|
|
}
|
|
}
|
|
}
|
|
else if (!CanHandleInflux(1))
|
|
{
|
|
pm.SendLocalizedMessage(
|
|
1018031); // In the interest of faction stability, this faction declines to accept new members for now.
|
|
}
|
|
else
|
|
{
|
|
JoinAlone(mob);
|
|
}
|
|
}
|
|
|
|
public bool IsCommander(Mobile mob)
|
|
{
|
|
if (mob == null)
|
|
return false;
|
|
|
|
return mob.AccessLevel >= AccessLevel.GameMaster || mob == Commander;
|
|
}
|
|
|
|
public override string ToString() => m_Definition.FriendlyName;
|
|
|
|
public static bool CheckLeaveTimer(Mobile mob)
|
|
{
|
|
PlayerState pl = PlayerState.Find(mob);
|
|
|
|
if (pl?.IsLeaving != true)
|
|
return false;
|
|
|
|
if (pl.Leaving + LeavePeriod >= DateTime.UtcNow)
|
|
return false;
|
|
|
|
mob.SendLocalizedMessage(1005163); // You have now quit your faction
|
|
|
|
pl.Faction.RemoveMember(mob);
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void Initialize()
|
|
{
|
|
EventSink.Login += EventSink_Login;
|
|
EventSink.Logout += EventSink_Logout;
|
|
|
|
Timer.DelayCall(TimeSpan.FromMinutes(1.0), TimeSpan.FromMinutes(10.0), HandleAtrophy);
|
|
|
|
Timer.DelayCall(TimeSpan.FromSeconds(30.0), TimeSpan.FromSeconds(30.0), ProcessTick);
|
|
|
|
CommandSystem.Register("FactionElection", AccessLevel.GameMaster, FactionElection_OnCommand);
|
|
CommandSystem.Register("FactionCommander", AccessLevel.Administrator, FactionCommander_OnCommand);
|
|
CommandSystem.Register("FactionItemReset", AccessLevel.Administrator, FactionItemReset_OnCommand);
|
|
CommandSystem.Register("FactionReset", AccessLevel.Administrator, FactionReset_OnCommand);
|
|
CommandSystem.Register("FactionTownReset", AccessLevel.Administrator, FactionTownReset_OnCommand);
|
|
}
|
|
|
|
public static void FactionTownReset_OnCommand(CommandEventArgs e)
|
|
{
|
|
List<BaseMonolith> monoliths = BaseMonolith.Monoliths;
|
|
|
|
for (int i = 0; i < monoliths.Count; ++i)
|
|
monoliths[i].Sigil = null;
|
|
|
|
List<Town> towns = Town.Towns;
|
|
|
|
for (int i = 0; i < towns.Count; ++i)
|
|
{
|
|
towns[i].Silver = 0;
|
|
towns[i].Sheriff = null;
|
|
towns[i].Finance = null;
|
|
towns[i].Tax = 0;
|
|
towns[i].Owner = null;
|
|
}
|
|
|
|
List<Sigil> sigils = Sigil.Sigils;
|
|
|
|
for (int i = 0; i < sigils.Count; ++i)
|
|
{
|
|
sigils[i].Corrupted = null;
|
|
sigils[i].Corrupting = null;
|
|
sigils[i].LastStolen = DateTime.MinValue;
|
|
sigils[i].GraceStart = DateTime.MinValue;
|
|
sigils[i].CorruptionStart = DateTime.MinValue;
|
|
sigils[i].PurificationStart = DateTime.MinValue;
|
|
sigils[i].LastMonolith = null;
|
|
sigils[i].ReturnHome();
|
|
}
|
|
|
|
List<Faction> factions = Factions;
|
|
|
|
for (int i = 0; i < factions.Count; ++i)
|
|
{
|
|
Faction f = factions[i];
|
|
|
|
List<FactionItem> list = new List<FactionItem>(f.State.FactionItems);
|
|
|
|
for (int j = 0; j < list.Count; ++j)
|
|
{
|
|
FactionItem fi = list[j];
|
|
|
|
if (fi.Expiration == DateTime.MinValue)
|
|
fi.Item.Delete();
|
|
else
|
|
fi.Detach();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void FactionReset_OnCommand(CommandEventArgs e)
|
|
{
|
|
List<BaseMonolith> monoliths = BaseMonolith.Monoliths;
|
|
|
|
for (int i = 0; i < monoliths.Count; ++i)
|
|
monoliths[i].Sigil = null;
|
|
|
|
List<Town> towns = Town.Towns;
|
|
|
|
for (int i = 0; i < towns.Count; ++i)
|
|
{
|
|
towns[i].Silver = 0;
|
|
towns[i].Sheriff = null;
|
|
towns[i].Finance = null;
|
|
towns[i].Tax = 0;
|
|
towns[i].Owner = null;
|
|
}
|
|
|
|
List<Sigil> sigils = Sigil.Sigils;
|
|
|
|
for (int i = 0; i < sigils.Count; ++i)
|
|
{
|
|
sigils[i].Corrupted = null;
|
|
sigils[i].Corrupting = null;
|
|
sigils[i].LastStolen = DateTime.MinValue;
|
|
sigils[i].GraceStart = DateTime.MinValue;
|
|
sigils[i].CorruptionStart = DateTime.MinValue;
|
|
sigils[i].PurificationStart = DateTime.MinValue;
|
|
sigils[i].LastMonolith = null;
|
|
sigils[i].ReturnHome();
|
|
}
|
|
|
|
List<Faction> factions = Factions;
|
|
|
|
for (int i = 0; i < factions.Count; ++i)
|
|
{
|
|
Faction f = factions[i];
|
|
|
|
List<PlayerState> playerStateList = new List<PlayerState>(f.Members);
|
|
|
|
for (int j = 0; j < playerStateList.Count; ++j)
|
|
f.RemoveMember(playerStateList[j].Mobile);
|
|
|
|
List<FactionItem> factionItemList = new List<FactionItem>(f.State.FactionItems);
|
|
|
|
for (int j = 0; j < factionItemList.Count; ++j)
|
|
{
|
|
FactionItem fi = factionItemList[j];
|
|
|
|
if (fi.Expiration == DateTime.MinValue)
|
|
fi.Item.Delete();
|
|
else
|
|
fi.Detach();
|
|
}
|
|
|
|
List<BaseFactionTrap> factionTrapList = new List<BaseFactionTrap>(f.Traps);
|
|
|
|
for (int j = 0; j < factionTrapList.Count; ++j)
|
|
factionTrapList[j].Delete();
|
|
}
|
|
}
|
|
|
|
public static void FactionItemReset_OnCommand(CommandEventArgs e)
|
|
{
|
|
List<Item> items = new List<Item>();
|
|
|
|
foreach (Item item in World.Items.Values)
|
|
if (item is IFactionItem && !(item is HoodedShroudOfShadows))
|
|
items.Add(item);
|
|
|
|
int[] hues = new int[Factions.Count * 2];
|
|
|
|
for (int i = 0; i < Factions.Count; ++i)
|
|
{
|
|
hues[0 + i * 2] = Factions[i].Definition.HuePrimary;
|
|
hues[1 + i * 2] = Factions[i].Definition.HueSecondary;
|
|
}
|
|
|
|
int count = 0;
|
|
|
|
for (int i = 0; i < items.Count; ++i)
|
|
{
|
|
Item item = items[i];
|
|
IFactionItem fci = (IFactionItem)item;
|
|
|
|
if (fci.FactionItemState != null || item.LootType != LootType.Blessed)
|
|
continue;
|
|
|
|
bool isHued = false;
|
|
|
|
for (int j = 0; j < hues.Length; ++j)
|
|
if (item.Hue == hues[j])
|
|
{
|
|
isHued = true;
|
|
break;
|
|
}
|
|
|
|
if (isHued)
|
|
{
|
|
fci.FactionItemState = null;
|
|
++count;
|
|
}
|
|
}
|
|
|
|
e.Mobile.SendMessage("{0} items reset", count);
|
|
}
|
|
|
|
public static void FactionCommander_OnCommand(CommandEventArgs e)
|
|
{
|
|
e.Mobile.SendMessage("Target a player to make them the faction commander.");
|
|
e.Mobile.BeginTarget(-1, false, TargetFlags.None, FactionCommander_OnTarget);
|
|
}
|
|
|
|
public static void FactionCommander_OnTarget(Mobile from, object obj)
|
|
{
|
|
if (obj is PlayerMobile mobile)
|
|
{
|
|
Mobile targ = mobile;
|
|
PlayerState pl = PlayerState.Find(targ);
|
|
|
|
if (pl != null)
|
|
{
|
|
pl.Faction.Commander = targ;
|
|
from.SendMessage("You have appointed them as the faction commander.");
|
|
}
|
|
else
|
|
{
|
|
from.SendMessage("They are not in a faction.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
from.SendMessage("That is not a player.");
|
|
}
|
|
}
|
|
|
|
public static void FactionElection_OnCommand(CommandEventArgs e)
|
|
{
|
|
e.Mobile.SendMessage("Target a faction stone to open its election properties.");
|
|
e.Mobile.BeginTarget(-1, false, TargetFlags.None, FactionElection_OnTarget);
|
|
}
|
|
|
|
public static void FactionElection_OnTarget(Mobile from, object obj)
|
|
{
|
|
if (obj is FactionStone stone)
|
|
{
|
|
Faction faction = stone.Faction;
|
|
|
|
if (faction != null)
|
|
from.SendGump(new ElectionManagementGump(faction.Election));
|
|
// from.SendGump( new Gumps.PropertiesGump( from, faction.Election ) );
|
|
else
|
|
from.SendMessage("That stone has no faction assigned.");
|
|
}
|
|
else
|
|
{
|
|
from.SendMessage("That is not a faction stone.");
|
|
}
|
|
}
|
|
|
|
public static void FactionKick_OnCommand(CommandEventArgs e)
|
|
{
|
|
e.Mobile.SendMessage("Target a player to remove them from their faction.");
|
|
e.Mobile.BeginTarget(-1, false, TargetFlags.None, FactionKick_OnTarget);
|
|
}
|
|
|
|
public static void FactionKick_OnTarget(Mobile from, object obj)
|
|
{
|
|
if (obj is Mobile mob)
|
|
{
|
|
PlayerState pl = PlayerState.Find(mob);
|
|
|
|
if (pl != null)
|
|
{
|
|
pl.Faction.RemoveMember(mob);
|
|
|
|
mob.SendMessage("You have been kicked from your faction.");
|
|
from.SendMessage("They have been kicked from their faction.");
|
|
}
|
|
else
|
|
{
|
|
from.SendMessage("They are not in a faction.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
from.SendMessage("That is not a player.");
|
|
}
|
|
}
|
|
|
|
public static void ProcessTick()
|
|
{
|
|
List<Sigil> sigils = Sigil.Sigils;
|
|
|
|
for (int i = 0; i < sigils.Count; ++i)
|
|
{
|
|
Sigil sigil = sigils[i];
|
|
|
|
if (!sigil.IsBeingCorrupted && sigil.GraceStart != DateTime.MinValue &&
|
|
sigil.GraceStart + Sigil.CorruptionGrace < DateTime.UtcNow)
|
|
{
|
|
if (sigil.LastMonolith is StrongholdMonolith &&
|
|
(sigil.Corrupted == null || sigil.LastMonolith.Faction != sigil.Corrupted))
|
|
{
|
|
sigil.Corrupting = sigil.LastMonolith.Faction;
|
|
sigil.CorruptionStart = DateTime.UtcNow;
|
|
}
|
|
else
|
|
{
|
|
sigil.Corrupting = null;
|
|
sigil.CorruptionStart = DateTime.MinValue;
|
|
}
|
|
|
|
sigil.GraceStart = DateTime.MinValue;
|
|
}
|
|
|
|
if (sigil.LastMonolith?.Sigil == null)
|
|
{
|
|
if (sigil.LastStolen + Sigil.ReturnPeriod < DateTime.UtcNow)
|
|
sigil.ReturnHome();
|
|
}
|
|
else
|
|
{
|
|
if (sigil.IsBeingCorrupted && sigil.CorruptionStart + Sigil.CorruptionPeriod < DateTime.UtcNow)
|
|
{
|
|
sigil.Corrupted = sigil.Corrupting;
|
|
sigil.Corrupting = null;
|
|
sigil.CorruptionStart = DateTime.MinValue;
|
|
sigil.GraceStart = DateTime.MinValue;
|
|
}
|
|
else if (sigil.IsPurifying && sigil.PurificationStart + Sigil.PurificationPeriod < DateTime.UtcNow)
|
|
{
|
|
sigil.PurificationStart = DateTime.MinValue;
|
|
sigil.Corrupted = null;
|
|
sigil.Corrupting = null;
|
|
sigil.CorruptionStart = DateTime.MinValue;
|
|
sigil.GraceStart = DateTime.MinValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void HandleDeath(Mobile mob)
|
|
{
|
|
HandleDeath(mob, null);
|
|
}
|
|
|
|
public int AwardSilver(Mobile mob, int silver)
|
|
{
|
|
if (silver <= 0)
|
|
return 0;
|
|
|
|
int tithed = silver * Tithe / 100;
|
|
|
|
Silver += tithed;
|
|
|
|
silver = silver - tithed;
|
|
|
|
if (silver > 0)
|
|
mob.AddToBackpack(new Silver(silver));
|
|
|
|
return silver;
|
|
}
|
|
|
|
public static Faction FindSmallestFaction()
|
|
{
|
|
List<Faction> factions = Factions;
|
|
Faction smallest = null;
|
|
|
|
for (int i = 0; i < factions.Count; ++i)
|
|
{
|
|
Faction faction = factions[i];
|
|
|
|
if (smallest == null || faction.Members.Count < smallest.Members.Count)
|
|
smallest = faction;
|
|
}
|
|
|
|
return smallest;
|
|
}
|
|
|
|
public static bool StabilityActive()
|
|
{
|
|
List<Faction> factions = Factions;
|
|
|
|
for (int i = 0; i < factions.Count; ++i)
|
|
{
|
|
Faction faction = factions[i];
|
|
|
|
if (faction.Members.Count > StabilityActivation)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public bool CanHandleInflux(int influx)
|
|
{
|
|
if (!StabilityActive())
|
|
return true;
|
|
|
|
Faction smallest = FindSmallestFaction();
|
|
|
|
if (smallest == null)
|
|
return true; // sanity
|
|
|
|
if ((Members.Count + influx) * 100 / StabilityFactor > smallest.Members.Count)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void HandleDeath(Mobile victim, Mobile killer)
|
|
{
|
|
killer ??= victim.FindMostRecentDamager(true);
|
|
|
|
PlayerState killerState = PlayerState.Find(killer);
|
|
Container killerPack = killer?.Backpack;
|
|
victim.Backpack?.FindItemsByType<Sigil>().ForEach(sigil =>
|
|
{
|
|
if (killerState == null || killerPack == null)
|
|
{
|
|
sigil.ReturnHome();
|
|
return;
|
|
}
|
|
|
|
if (killer?.GetDistanceToSqrt(victim) > 64)
|
|
{
|
|
sigil.ReturnHome();
|
|
killer.SendLocalizedMessage(1042230); // The sigil has gone back to its home location.
|
|
}
|
|
else if (Sigil.ExistsOn(killer))
|
|
{
|
|
sigil.ReturnHome();
|
|
killer?.SendLocalizedMessage(
|
|
1010258); // The sigil has gone back to its home location because you already have a sigil.
|
|
}
|
|
else if (!killerPack.TryDropItem(killer, sigil, false))
|
|
{
|
|
sigil.ReturnHome();
|
|
killer?.SendLocalizedMessage(1010259); // The sigil has gone home because your backpack is full.
|
|
}
|
|
});
|
|
|
|
if (killerState == null)
|
|
return;
|
|
|
|
if (victim is BaseCreature bc)
|
|
{
|
|
Faction victimFaction = bc.FactionAllegiance;
|
|
|
|
if (bc.Map == Facet && victimFaction != null && killerState.Faction != victimFaction)
|
|
{
|
|
int silver = killerState.Faction.AwardSilver(killer, bc.FactionSilverWorth);
|
|
|
|
if (silver > 0)
|
|
killer?.SendLocalizedMessage(1042748,
|
|
silver.ToString("N0")); // Thou hast earned ~1_AMOUNT~ silver for vanquishing the vile creature.
|
|
}
|
|
|
|
if (bc.Map == Facet && bc.GetEthicAllegiance(killer) == BaseCreature.Allegiance.Enemy)
|
|
{
|
|
Player killerEPL = Player.Find(killer);
|
|
|
|
if (killerEPL != null && 100 - killerEPL.Power > Utility.Random(100))
|
|
{
|
|
++killerEPL.Power;
|
|
++killerEPL.History;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
PlayerState victimState = PlayerState.Find(victim);
|
|
|
|
if (victimState == null)
|
|
return;
|
|
|
|
if (victim.Region.IsPartOf<SafeZone>())
|
|
return;
|
|
|
|
if (killer == victim || killerState.Faction != victimState.Faction)
|
|
ApplySkillLoss(victim);
|
|
|
|
if (killerState.Faction != victimState.Faction)
|
|
{
|
|
if (victimState.KillPoints <= -6)
|
|
{
|
|
killer?.SendLocalizedMessage(501693); // This victim is not worth enough to get kill points from.
|
|
|
|
Player killerEPL = Player.Find(killer);
|
|
Player victimEPL = Player.Find(victim);
|
|
|
|
if (killerEPL != null && victimEPL?.Power > 0 && victimState.CanGiveSilverTo(killer))
|
|
{
|
|
int powerTransfer = Math.Max(1, victimEPL.Power / 5);
|
|
|
|
if (powerTransfer > 100 - killerEPL.Power)
|
|
powerTransfer = 100 - killerEPL.Power;
|
|
|
|
if (powerTransfer > 0)
|
|
{
|
|
victimEPL.Power -= (powerTransfer + 1) / 2;
|
|
killerEPL.Power += powerTransfer;
|
|
|
|
killerEPL.History += powerTransfer;
|
|
|
|
victimState.OnGivenSilverTo(killer);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int award = Math.Max(victimState.KillPoints / 10, 1);
|
|
|
|
if (award > 40)
|
|
award = 40;
|
|
|
|
if (victimState.CanGiveSilverTo(killer))
|
|
{
|
|
PowerFactionItem.CheckSpawn(killer, victim);
|
|
|
|
if (victimState.KillPoints > 0)
|
|
{
|
|
victimState.IsActive = true;
|
|
|
|
if (Utility.Random(3) < 1)
|
|
killerState.IsActive = true;
|
|
|
|
int silver = killerState.Faction.AwardSilver(killer, award * 40);
|
|
|
|
if (silver > 0)
|
|
killer?.SendLocalizedMessage(1042736,
|
|
$"{silver:N0} silver\t{victim.Name}"); // You have earned ~1_SILVER_AMOUNT~ pieces for vanquishing ~2_PLAYER_NAME~!
|
|
}
|
|
|
|
victimState.KillPoints -= award;
|
|
killerState.KillPoints += award;
|
|
|
|
int offset = award != 1 ? 0 : 2; // for pluralization
|
|
|
|
string args = $"{award}\t{victim.Name}\t{killer?.Name}";
|
|
|
|
killer?.SendLocalizedMessage(1042737 + offset,
|
|
args); // Thou hast been honored with ~1_KILL_POINTS~ kill point(s) for vanquishing ~2_DEAD_PLAYER~!
|
|
victim.SendLocalizedMessage(1042738 + offset,
|
|
args); // Thou has lost ~1_KILL_POINTS~ kill point(s) to ~3_ATTACKER_NAME~ for being vanquished!
|
|
|
|
Player killerEPL = Player.Find(killer);
|
|
Player victimEPL = Player.Find(victim);
|
|
|
|
if (killerEPL != null && victimEPL?.Power > 0)
|
|
{
|
|
int powerTransfer = Math.Max(1, victimEPL.Power / 5);
|
|
|
|
if (powerTransfer > 100 - killerEPL.Power)
|
|
powerTransfer = 100 - killerEPL.Power;
|
|
|
|
if (powerTransfer > 0)
|
|
{
|
|
victimEPL.Power -= (powerTransfer + 1) / 2;
|
|
killerEPL.Power += powerTransfer;
|
|
|
|
killerEPL.History += powerTransfer;
|
|
}
|
|
}
|
|
|
|
victimState.OnGivenSilverTo(killer);
|
|
}
|
|
else
|
|
{
|
|
killer?.SendLocalizedMessage(
|
|
1042231); // You have recently defeated this enemy and thus their death brings you no honor.
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void EventSink_Logout(Mobile m)
|
|
{
|
|
m.Backpack?.FindItemsByType<Sigil>().ForEach(sigil => sigil.ReturnHome());
|
|
}
|
|
|
|
private static void EventSink_Login(Mobile m) => CheckLeaveTimer(m);
|
|
|
|
public static void WriteReference(IGenericWriter writer, Faction fact)
|
|
{
|
|
int idx = Factions.IndexOf(fact);
|
|
|
|
writer.WriteEncodedInt(idx + 1);
|
|
}
|
|
|
|
public static Faction ReadReference(IGenericReader reader)
|
|
{
|
|
int idx = reader.ReadEncodedInt() - 1;
|
|
|
|
return idx >= 0 && idx < Factions.Count ? Factions[idx] : null;
|
|
}
|
|
|
|
public static Faction Find(Mobile mob, bool inherit = false, bool creatureAllegiances = false)
|
|
{
|
|
PlayerState pl = PlayerState.Find(mob);
|
|
|
|
if (pl != null)
|
|
return pl.Faction;
|
|
|
|
if (inherit && mob is BaseCreature bc)
|
|
{
|
|
if (bc.Controlled)
|
|
return Find(bc.ControlMaster);
|
|
if (bc.Summoned)
|
|
return Find(bc.SummonMaster);
|
|
if (creatureAllegiances && bc is BaseFactionGuard guard)
|
|
return guard.Faction;
|
|
if (creatureAllegiances)
|
|
return bc.FactionAllegiance;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static Faction Parse(string name)
|
|
{
|
|
List<Faction> factions = Factions;
|
|
|
|
for (int i = 0; i < factions.Count; ++i)
|
|
{
|
|
Faction faction = factions[i];
|
|
|
|
if (Insensitive.Equals(faction.Definition.FriendlyName, name))
|
|
return faction;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private class BroadcastPrompt : Prompt
|
|
{
|
|
private readonly Faction m_Faction;
|
|
|
|
public BroadcastPrompt(Faction faction) => m_Faction = faction;
|
|
|
|
public override void OnResponse(Mobile from, string text)
|
|
{
|
|
m_Faction.EndBroadcast(from, text);
|
|
}
|
|
}
|
|
|
|
public const double SkillLossFactor = 1.0 / 3;
|
|
public static readonly TimeSpan SkillLossPeriod = TimeSpan.FromMinutes(20.0);
|
|
|
|
private static readonly Dictionary<Mobile, SkillLossContext> m_SkillLoss = new Dictionary<Mobile, SkillLossContext>();
|
|
|
|
private class SkillLossContext
|
|
{
|
|
public List<SkillMod> m_Mods;
|
|
public Timer m_Timer;
|
|
}
|
|
|
|
public static bool InSkillLoss(Mobile mob) => m_SkillLoss.ContainsKey(mob);
|
|
|
|
public static void ApplySkillLoss(Mobile mob)
|
|
{
|
|
if (InSkillLoss(mob))
|
|
return;
|
|
|
|
SkillLossContext context = new SkillLossContext();
|
|
m_SkillLoss[mob] = context;
|
|
|
|
List<SkillMod> mods = context.m_Mods = new List<SkillMod>();
|
|
|
|
for (int i = 0; i < mob.Skills.Length; ++i)
|
|
{
|
|
Skill sk = mob.Skills[i];
|
|
double baseValue = sk.Base;
|
|
|
|
if (baseValue > 0)
|
|
{
|
|
SkillMod mod = new DefaultSkillMod(sk.SkillName, true, -(baseValue * SkillLossFactor));
|
|
|
|
mods.Add(mod);
|
|
mob.AddSkillMod(mod);
|
|
}
|
|
}
|
|
|
|
context.m_Timer = Timer.DelayCall(SkillLossPeriod, () => ClearSkillLoss(mob));
|
|
}
|
|
|
|
public static bool ClearSkillLoss(Mobile mob)
|
|
{
|
|
if (!m_SkillLoss.TryGetValue(mob, out SkillLossContext context))
|
|
return false;
|
|
|
|
m_SkillLoss.Remove(mob);
|
|
|
|
List<SkillMod> mods = context.m_Mods;
|
|
|
|
for (int i = 0; i < mods.Count; ++i)
|
|
mob.RemoveSkillMod(mods[i]);
|
|
|
|
context.m_Timer.Stop();
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public enum FactionKickType
|
|
{
|
|
Kick,
|
|
Ban,
|
|
Unban
|
|
}
|
|
|
|
public class FactionKickCommand : BaseCommand
|
|
{
|
|
private readonly FactionKickType m_KickType;
|
|
|
|
public FactionKickCommand(FactionKickType kickType)
|
|
{
|
|
m_KickType = kickType;
|
|
|
|
AccessLevel = AccessLevel.GameMaster;
|
|
Supports = CommandSupport.AllMobiles;
|
|
ObjectTypes = ObjectTypes.Mobiles;
|
|
|
|
switch (m_KickType)
|
|
{
|
|
case FactionKickType.Kick:
|
|
{
|
|
Commands = new[] { "FactionKick" };
|
|
Usage = "FactionKick";
|
|
Description =
|
|
"Kicks the targeted player out of his current faction. This does not prevent them from rejoining.";
|
|
break;
|
|
}
|
|
case FactionKickType.Ban:
|
|
{
|
|
Commands = new[] { "FactionBan" };
|
|
Usage = "FactionBan";
|
|
Description =
|
|
"Bans the account of a targeted player from joining factions. All players on the account are removed from their current faction, if any.";
|
|
break;
|
|
}
|
|
case FactionKickType.Unban:
|
|
{
|
|
Commands = new[] { "FactionUnban" };
|
|
Usage = "FactionUnban";
|
|
Description = "Unbans the account of a targeted player from joining factions.";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Execute(CommandEventArgs e, object obj)
|
|
{
|
|
Mobile mob = (Mobile)obj;
|
|
|
|
switch (m_KickType)
|
|
{
|
|
case FactionKickType.Kick:
|
|
{
|
|
PlayerState pl = PlayerState.Find(mob);
|
|
|
|
if (pl != null)
|
|
{
|
|
pl.Faction.RemoveMember(mob);
|
|
mob.SendMessage("You have been kicked from your faction.");
|
|
AddResponse("They have been kicked from their faction.");
|
|
}
|
|
else
|
|
{
|
|
LogFailure("They are not in a faction.");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case FactionKickType.Ban:
|
|
{
|
|
if (mob.Account is Account acct)
|
|
{
|
|
if (acct.GetTag("FactionBanned") == null)
|
|
{
|
|
acct.SetTag("FactionBanned", "true");
|
|
AddResponse("The account has been banned from joining factions.");
|
|
}
|
|
else
|
|
{
|
|
AddResponse("The account is already banned from joining factions.");
|
|
}
|
|
|
|
for (int i = 0; i < acct.Length; ++i)
|
|
{
|
|
mob = acct[i];
|
|
|
|
if (mob != null)
|
|
{
|
|
PlayerState pl = PlayerState.Find(mob);
|
|
|
|
if (pl != null)
|
|
{
|
|
pl.Faction.RemoveMember(mob);
|
|
mob.SendMessage("You have been kicked from your faction.");
|
|
AddResponse("They have been kicked from their faction.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogFailure("They have no assigned account.");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case FactionKickType.Unban:
|
|
{
|
|
if (mob.Account is Account acct)
|
|
{
|
|
if (acct.GetTag("FactionBanned") == null)
|
|
{
|
|
AddResponse("The account is not already banned from joining factions.");
|
|
}
|
|
else
|
|
{
|
|
acct.RemoveTag("FactionBanned");
|
|
AddResponse("The account may now freely join factions.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LogFailure("They have no assigned account.");
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|