/// <summary>
/// Handles the JailInfo command, stating to the player information about their jailtime
/// </summary>
private static void OnJailInfoCommand(CommandEventArgs e)
{
JailEntry jail = GetCurrentJail(e.Mobile);
if (jail == null)
{
e.Mobile.SendMessage("You must be jailed to use this.");
return;
}
if (!jail.AutoRelease)
{
e.Mobile.SendMessage("Your sentence has no auto release date. A staff member will have to manually release you.");
return;
}
TimeSpan left = jail.EndTime - DateTime.UtcNow;
if (left > TimeSpan.Zero)
{
e.Mobile.SendMessage(
"Your sentence will expire in {0} days, {1} hours and {2} minutes.", left.Days, left.Hours, left.Minutes);
}
else if (jail.EndTime > DateTime.UtcNow)
{
Release(jail, null);
}
}
public PlayerJailGump(JailEntry jail, Mobile jailer) : base(100, 100)
{
m_Jail = jail;
m_Jailer = jailer;
MakeGump();
}
/// <summary>
/// Loads a jailing from an Xml Node
/// </summary>
/// <param name="xNode">The XmlNode containing the jailing</param>
/// <returns>A JailEntry object</returns>
public static JailEntry Load(XmlNode xNode)
{
JailEntry jail = new JailEntry();
// Account
string account = xNode.Attributes["Account"].Value;
if (!String.IsNullOrEmpty(account))
{
jail.m_Account = (Account)Accounts.GetAccount(account);
}
// Mobile
int serial = Utility.ToInt32(xNode.Attributes["Mobile"].Value);
if (serial > -1)
{
jail.m_Mobile = World.FindMobile((Serial)serial);
}
// Jail Time
jail.m_JailTime = Utility.GetXMLDateTime(xNode.Attributes["JailTime"].Value, DateTime.MinValue);
// Duration
jail.Duration = Utility.GetXMLTimeSpan(xNode.Attributes["Duration"].Value, TimeSpan.Zero);
// JailedBy
jail.m_JailedBy = xNode.Attributes["JailedBy"].Value;
// Reason
jail.m_Reason = xNode.Attributes["Reason"].Value;
// History Record
jail.m_HistoryRecord = xNode.Attributes["HistoryRecord"].Value;
// Autorelease
bool autorelease;
bool.TryParse(xNode.Attributes["AutoRelease"].Value, out autorelease);
jail.m_AutoRelease = autorelease;
// Full jail
bool fulljail;
bool.TryParse(xNode.Attributes["FullJail"].Value, out fulljail);
jail.m_FullJail = fulljail;
if (xNode.ChildNodes.Count > 0)
{
XmlNode xComments = xNode.ChildNodes[0];
foreach (XmlNode xCom in xComments.ChildNodes)
{
jail.m_Comments.Add(xCom.Attributes["Value"].Value);
}
}
return(jail);
}
public JailAccountGump( Mobile offender, Mobile user, JailEntry jail, Account account ) : base( 100, 100 )
{
m_Offender = offender;
m_User = user;
m_ExistingJail = jail;
m_Account = account;
MakeGump();
}
public JailAccountGump(Mobile offender, Mobile user, JailEntry jail, Account account) : base(100, 100)
{
m_Offender = offender;
m_User = user;
m_ExistingJail = jail;
m_Account = account;
MakeGump();
}
public JailViewGump(Mobile user, JailEntry jail, JailGumpCallback callback) : base(50, 50)
{
user.CloseGump(typeof(JailViewGump));
m_User = user;
m_Jail = jail;
m_Callback = callback;
MakeGump();
}
public JailViewGump( Mobile user, JailEntry jail, JailGumpCallback callback ) : base( 50, 50 )
{
user.CloseGump( typeof( JailViewGump ) );
m_User = user;
m_Jail = jail;
m_Callback = callback;
MakeGump();
}
/// <summary>
/// Finalizes a jailing action by adding a jail record and moving the mobile into a jail cell
/// </summary>
/// <param name="m">The player being jailed</param>
/// <param name="account">The account of the player being jailed</param>
/// <param name="from">The GM performing the jailing</param>
/// <param name="reason">The reason for the jailing</param>
/// <param name="autorelease">States if the player should be auto released after the sentence is over</param>
/// <param name="duration">The length of the sentence</param>
/// <param name="fulljail">States if the full account should be jailed</param>
/// <param name="comment">An additional comment about the jailing</param>
public static void CommitJailing(
Mobile m,
Account account,
Mobile from,
string reason,
bool autorelease,
TimeSpan duration,
bool fulljail,
string comment)
{
var jail = new JailEntry(m, account, from, duration, reason, comment, autorelease, fulljail);
// Verify if the new entry is valid
JailEntry existing = null;
if (!IsValid(jail))
{
existing = jail.Mobile != null?GetCurrentJail(jail.Mobile) : GetCurrentJail(jail.Account);
}
if (existing != null)
{
// This jailing wont' be committed, if there's a pending player, release them
CancelJail(m, from);
from.SendMessage(
0x40,
"Your new jail report is in conflict with an existing entry. Please review and eventually update the existing jailing.");
from.SendGump(new JailViewGump(from, existing, null));
return;
}
// The jailing is valid so go on and add it
m_Jailings.Add(jail);
FinalizeJail(m);
// Send jailing review gump to the offender
if (m != null && m.NetState != null)
{
m.SendGump(new PlayerJailGump(jail, from));
}
else if (jail.FullJail) // Handle full account jailing/player relogging
{
Mobile mob = GetOnlineMobile(jail.Account);
if (mob != null)
{
FinalizeJail(mob);
mob.SendGump(new PlayerJailGump(jail, from));
}
}
}
/// <summary>
/// Callback for the Unjail command target
/// </summary>
/// <param name="from">The GM using the command</param>
/// <param name="target">The player being unjailed</param>
private static void OnUnjailTarget(Mobile from, Mobile target)
{
JailEntry jail = GetCurrentJail(target);
if (jail == null)
{
from.SendMessage("That player isn't currently jailed.");
}
else
{
Release(jail, from);
}
}
/// <summary>
/// Views information on the jail status of the target
/// </summary>
/// <param name="from">The GM requesting the information</param>
/// <param name="target">The target being searched for jail information</param>
private static void OnJailInfoTarget(Mobile from, Mobile target)
{
JailEntry jail = GetCurrentJail(target);
if (jail == null)
{
from.SendMessage("That player isn't currently jailed.");
}
else
{
from.SendGump(new JailViewGump(from, jail, null));
}
}
/// <summary>
/// Verifies if a JailEntry should be removed from history
/// </summary>
/// <param name="jail">The JailEntry object being checked</param>
/// <returns>True if the JailEntry matches the purge conditions</returns>
public bool PurgeCheck( JailEntry jail )
{
if ( jail.Account == null || m_Deleted || ( jail.Account.Banned && m_Banned ) )
return true;
else if ( m_Old )
{
TimeSpan age = DateTime.UtcNow - jail.JailTime;
if ( age.TotalHours >= m_Hours )
return true;
}
return false;
}
/// <summary>
/// Forces a release action on a JailEntry. This also adds a comment specifying the moment of the release.
/// </summary>
/// <param name="jail">The jail entry to consider expired</param>
/// <param name="from">The staff member releasing the jailing</param>
public static void Release(JailEntry jail, Mobile from)
{
if (from != null)
{
jail.AddComment(from, "Released at {0}", DateTime.UtcNow.ToShortTimeString());
}
jail.Release();
if (m_Jailings.Contains(jail))
{
m_Jailings.Remove(jail);
m_ExpiredJailings.Add(jail);
}
}
/// <summary>
/// Verifies if a JailEntry should be removed from history
/// </summary>
/// <param name="jail">The JailEntry object being checked</param>
/// <returns>True if the JailEntry matches the purge conditions</returns>
public bool PurgeCheck(JailEntry jail)
{
if (jail.Account == null || m_Deleted || (jail.Account.Banned && m_Banned))
{
return(true);
}
else if (m_Old)
{
TimeSpan age = DateTime.Now - jail.JailTime;
if (age.TotalHours >= m_Hours)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Verifies if a new jail entry has conflicts with other jail entries
/// </summary>
/// <param name="jail">The potential new JailEntry</param>
/// <returns>True if the new jail entry can be added to the jail</returns>
private static bool IsValid(JailEntry jail)
{
foreach (JailEntry cmp in m_Jailings)
{
if (jail.Account == cmp.Account)
{
if (cmp.FullJail && jail.FullJail)
{
return(false); // New jail is full account, and a previous full jail already exists
}
else if (cmp.Mobile == jail.Mobile && cmp.FullJail == jail.FullJail)
{
return(false); // Jailing the same mobile without full jail
}
}
}
return(true);
}
/// <summary>
/// Loads a file containing the jail entries
/// </summary>
/// <param name="filename">The filename to load</param>
/// <returns></returns>
private static IEnumerable <JailEntry> LoadJailFile(string filename)
{
var jailings = new List <JailEntry>();
var dom = new XmlDocument();
if (File.Exists(filename))
{
try
{
dom.Load(filename);
}
catch
{ }
if (dom.ChildNodes.Count < 2)
{
return(jailings);
}
XmlNode xItems = dom.ChildNodes[1];
foreach (XmlNode xJail in xItems.ChildNodes)
{
JailEntry jail = null;
try // If modified manually, some entries might be broken
{
jail = JailEntry.Load(xJail);
}
finally
{
if (jail != null)
{
jailings.Add(jail);
}
}
}
}
return(jailings);
}
/// <summary>
/// Initializes a jailing action by sending the JailReasonGump
/// </summary>
/// <param name="from">The GM performing the jailing</param>
/// <param name="offender">The account being jailed</param>
/// <returns>True if the jailing can proceed</returns>
public static bool InitJail(Mobile from, Account offender)
{
if (CanBeJailed(offender))
{
from.SendGump(new JailReasonGump(offender));
return(true);
}
JailEntry jail = GetCurrentJail(offender);
if (jail == null)
{
from.SendMessage("You can't jail that account because it's either already jailed or a staff account.");
}
else
{
from.SendMessage("That account has already been jailed. Please review the existing jail record.");
from.SendGump(new JailViewGump(from, jail, null));
}
return(false);
}
/// <summary>
/// Initializes a jailing action by sending the JailReasonGump
/// </summary>
/// <param name="from">The GM performing the jailing</param>
/// <param name="offender">The Mobile being jailed</param>
/// <param name="forceJail">Specifies whether the jailing of the player should be forced vs an existing account jail</param>
/// <returns>True if the jailing action is succesful</returns>
public static bool InitJail(Mobile from, Mobile offender, bool forceJail)
{
if (offender == null)
{
return(false);
}
if (CanBeJailed(offender))
{
// Check for existing non-full jail entries
JailEntry jail = GetAccountJail(offender);
if (jail != null && !forceJail)
{
// Existing entry: ask for conversion
from.SendGump(new JailAccountGump(offender, from, jail, offender.Account as Account));
return(false);
}
from.SendGump(new JailReasonGump(offender));
return(true);
}
else
{
JailEntry jail = GetCurrentJail(offender);
if (jail != null)
{
from.SendMessage("That player is already jailed. Please review the current jail record.");
from.SendGump(new JailViewGump(from, jail, null));
}
else
{
from.SendMessage("You can't jail that player because they're either already jailed or a staff member.");
}
return(false);
}
}
/// <summary>
/// Loads a jailing from an Xml Node
/// </summary>
/// <param name="xNode">The XmlNode containing the jailing</param>
/// <returns>A JailEntry object</returns>
public static JailEntry Load( XmlNode xNode )
{
JailEntry jail = new JailEntry();
// Account
string account = xNode.Attributes[ "Account" ].Value;
if ( !String.IsNullOrEmpty( account ) )
jail.m_Account = (Account)Accounts.GetAccount( account );
// Mobile
int serial = Utility.ToInt32( xNode.Attributes[ "Mobile" ].Value );
if ( serial > -1 )
jail.m_Mobile = World.FindMobile( (Serial) serial );
// Jail Time
jail.m_JailTime = Utility.GetXMLDateTime( xNode.Attributes[ "JailTime" ].Value, DateTime.MinValue );
// Duration
jail.Duration = Utility.GetXMLTimeSpan( xNode.Attributes[ "Duration" ].Value, TimeSpan.Zero );
// JailedBy
jail.m_JailedBy = xNode.Attributes[ "JailedBy" ].Value;
// Reason
jail.m_Reason = xNode.Attributes[ "Reason" ].Value;
// History Record
jail.m_HistoryRecord = xNode.Attributes[ "HistoryRecord" ].Value;
// Autorelease
bool autorelease;
bool.TryParse( xNode.Attributes[ "AutoRelease" ].Value, out autorelease );
jail.m_AutoRelease = autorelease;
// Full jail
bool fulljail;
bool.TryParse( xNode.Attributes[ "FullJail" ].Value, out fulljail );
jail.m_FullJail = fulljail;
if ( xNode.ChildNodes.Count > 0 )
{
XmlNode xComments = xNode.ChildNodes[ 0 ];
foreach( XmlNode xCom in xComments.ChildNodes )
jail.m_Comments.Add( xCom.Attributes[ "Value" ].Value );
}
return jail;
}
public override void OnResponse(Server.Network.NetState sender, RelayInfo info)
{
switch (info.ButtonID)
{
case 0: // Close
if (m_Callback != null)
{
try
{
m_Callback.DynamicInvoke(new object[] { m_User });
}
catch {}
}
break;
case 1: // Previous Page
m_User.SendGump(new JailListingGump(m_User, m_MasterList, m_Page - 1, m_Callback));
break;
case 2: // Next Page
m_User.SendGump(new JailListingGump(m_User, m_MasterList, m_Page + 1, m_Callback));
break;
default:
int type = info.ButtonID / 10;
int index = info.ButtonID % 10;
JailEntry jail = m_Jailings[index];
if (jail != null)
{
switch (type)
{
case 1: // View Information
{
m_User.SendGump(new JailViewGump(m_User, jail, new JailGumpCallback(JailListingCallback)));
break;
}
case 2: // View Account details
{
m_User.SendGump(new JailListingGump(m_User, m_MasterList, m_Page, m_Callback));
if (jail.Account != null)
{
m_User.SendGump(new AdminGump(m_User, AdminGumpPage.AccountDetails_Information, 0, null, "Requested by the Jail System", jail.Account));
}
break;
}
case 3: // View Player props
{
m_User.SendGump(new JailListingGump(m_User, m_MasterList, m_Page, m_Callback));
if (m_User.AccessLevel < AccessLevel.Lead)
{
return;
}
if (jail.Mobile != null)
{
m_User.SendGump(new PropertiesGump(m_User, jail.Mobile));
}
break;
}
}
}
break;
}
}
private void MakeGump()
{
this.Closable = true;
this.Disposable = true;
this.Dragable = true;
this.Resizable = false;
this.AddPage(0);
this.AddBackground(0, 0, 420, 315, 9250);
this.AddImageTiled(15, 15, 16, 285, 2624);
// Title
this.AddAlphaRegion(35, 15, 370, 20);
this.AddLabel(40, 15, GreenHue, string.Format("Jail Listing: Displaying {0} records", m_MasterList.Count));
// Table headers: Account
this.AddImageTiled(35, 40, 110, 20, 9304);
this.AddAlphaRegion(35, 40, 110, 20);
this.AddLabel(40, 40, LabelHue, @"Account");
// Player
this.AddImageTiled(150, 40, 110, 20, 9304);
this.AddAlphaRegion(150, 40, 110, 20);
this.AddLabel(155, 40, LabelHue, @"Player");
// Reason
this.AddImageTiled(265, 40, 140, 20, 9304);
this.AddAlphaRegion(265, 40, 140, 20);
this.AddLabel(270, 40, LabelHue, @"Reason");
// Table Background
this.AddAlphaRegion(35, 65, 110, 200);
this.AddImageTiled(150, 65, 110, 200, 3604);
this.AddAlphaRegion(150, 65, 110, 200);
this.AddAlphaRegion(265, 65, 140, 200);
this.AddAlphaRegion(35, 270, 370, 30);
// Close: Button 0
this.AddButton(45, 275, 4017, 4018, 0, GumpButtonType.Reply, 0);
this.AddLabel(80, 275, LabelHue, @"Close");
if (m_MasterList.Count == 0)
{
return;
}
// Data Section. Verify bounds
if (m_Page * 10 >= m_MasterList.Count)
{
// Show last page
m_Page = (m_MasterList.Count - 1) / 10;
}
if (m_Page > 0)
{
// Prev Page: Button 1
this.AddButton(335, 275, 4014, 4015, 1, GumpButtonType.Reply, 0);
}
if (m_Page < (m_MasterList.Count - 1) / 10)
{
// Next Page: Button 2
this.AddButton(370, 275, 4005, 4006, 2, GumpButtonType.Reply, 0);
}
for (int i = m_Page * 10; i < m_Page * 10 + 10 && i < m_MasterList.Count; i++)
{
int index = i - m_Page * 10;
JailEntry jail = m_MasterList[i];
// Jail Details: Buttons from 10 to 19
this.AddButton(15, 67 + index * 20, 5601, 5605, 10 + index, GumpButtonType.Reply, 0);
// Account details: Buttons from 20 to 29
if (jail.Account != null && m_User.AccessLevel == AccessLevel.Administrator)
{
this.AddButton(35, 69 + index * 20, 2224, 2224, 20 + index, GumpButtonType.Reply, 0);
}
// Account name
if (jail.Account != null)
{
this.AddLabelCropped(55, 65 + index * 20, 90, 20, LabelHue, jail.Account.Username);
}
else
{
this.AddLabelCropped(55, 65 + index * 20, 90, 20, RedHue, "Deleted");
}
// Player name
if (jail.Mobile != null)
{
// Player props: Buttons from 30 to 39
if (m_User.AccessLevel >= AccessLevel.GameMaster)
{
this.AddButton(150, 69 + index * 20, 2224, 2224, 30 + index, GumpButtonType.Reply, 0);
}
this.AddLabelCropped(170, 65 + index * 20, 90, 20, LabelHue, jail.Mobile.Name);
}
else
{
this.AddLabelCropped(170, 65 + index * 20, 90, 20, LabelHue, "N/A");
}
// Reason
this.AddLabelCropped(270, 65 + index * 20, 140, 20, LabelHue, jail.Reason);
}
}
/// <summary>
/// Verifies if a given jail entry is active or if it's a historical one
/// </summary>
/// <param name="jail">The JailEntry to verify</param>
/// <returns>True if the jail entry is currently active, false if it's historical</returns>
public static bool IsActive(JailEntry jail)
{
return(m_Jailings.Contains(jail));
}
/// <summary>
/// Loads a jailing from an Xml Node
/// </summary>
/// <param name="xNode">The XmlNode containing the jailing</param>
/// <returns>A JailEntry object</returns>
public static JailEntry Load( XmlNode xNode )
{
JailEntry jail = new JailEntry();
// Account
string account = xNode.Attributes[ "Account" ].Value;
if ( account != null )
{
jail.m_Account = Accounts.GetAccount(account) as Account;
}
// Mobile
int serial = -1;
try
{
serial = Convert.ToInt32( xNode.Attributes[ "Mobile" ].Value, 16 );
}
catch {};
if ( serial != -1 )
{
jail.m_Mobile = World.FindMobile( (Serial) serial );
}
// Jail Time
DateTime jailtime = DateTime.MinValue;
try
{
jailtime = DateTime.Parse( xNode.Attributes[ "JailTime" ].Value );
}
catch {}
jail.m_JailTime = jailtime;
// Duration
TimeSpan duration = TimeSpan.Zero;
try
{
duration = TimeSpan.Parse( xNode.Attributes[ "Duration" ].Value );
}
catch {}
jail.m_Duration = duration;
// JailedBy
jail.m_JailedBy = xNode.Attributes[ "JailedBy" ].Value;
// Reason
jail.m_Reason = xNode.Attributes[ "Reason" ].Value;
// History Record
jail.m_HistoryRecord = xNode.Attributes[ "HistoryRecord" ].Value;
// Autorelease
bool autorelease = false;
try
{
autorelease = bool.Parse( xNode.Attributes[ "AutoRelease" ].Value );
}
catch {}
jail.m_AutoRelease = autorelease;
// Full jail
bool fulljail = true;
try
{
fulljail = bool.Parse( xNode.Attributes[ "FullJail" ].Value );
}
catch {}
jail.m_FullJail = fulljail;
if ( xNode.ChildNodes.Count > 0 )
{
XmlNode xComments = xNode.ChildNodes[ 0 ];
foreach( XmlNode xCom in xComments.ChildNodes )
{
jail.m_Comments.Add( xCom.Attributes[ "Value" ].Value );
}
}
return jail;
}
