458 lines
11 KiB
C#
458 lines
11 KiB
C#
using System;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using Server;
|
|
using Server.Gumps;
|
|
using Server.Network;
|
|
using Server.Commands;
|
|
using Server.Commands.Generic;
|
|
|
|
namespace Server.Commands
|
|
{
|
|
public class Batch : BaseCommand
|
|
{
|
|
private BaseCommandImplementor m_Scope;
|
|
private string m_Condition;
|
|
private ArrayList m_BatchCommands;
|
|
|
|
public BaseCommandImplementor Scope
|
|
{
|
|
get{ return m_Scope; }
|
|
set{ m_Scope = value; }
|
|
}
|
|
|
|
public string Condition
|
|
{
|
|
get{ return m_Condition; }
|
|
set{ m_Condition = value; }
|
|
}
|
|
|
|
public ArrayList BatchCommands
|
|
{
|
|
get{ return m_BatchCommands; }
|
|
}
|
|
|
|
public Batch()
|
|
{
|
|
Commands = new string[]{ "Batch" };
|
|
ListOptimized = true;
|
|
|
|
m_BatchCommands = new ArrayList();
|
|
m_Condition = "";
|
|
}
|
|
|
|
public override void ExecuteList( CommandEventArgs e, ArrayList list )
|
|
{
|
|
if ( list.Count == 0 )
|
|
{
|
|
LogFailure( "Nothing was found to use this command on." );
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
BaseCommand[] commands = new BaseCommand[m_BatchCommands.Count];
|
|
CommandEventArgs[] eventArgs = new CommandEventArgs[m_BatchCommands.Count];
|
|
|
|
for ( int i = 0; i < m_BatchCommands.Count; ++i )
|
|
{
|
|
BatchCommand bc = (BatchCommand)m_BatchCommands[i];
|
|
|
|
string commandString, argString;
|
|
string[] args;
|
|
|
|
bc.GetDetails( out commandString, out argString, out args );
|
|
|
|
BaseCommand command = m_Scope.Commands[commandString];
|
|
|
|
commands[i] = command;
|
|
eventArgs[i] = new CommandEventArgs( e.Mobile, commandString, argString, args );
|
|
|
|
if ( command == null )
|
|
{
|
|
e.Mobile.SendMessage( "That is either an invalid command name or one that does not support this modifier: {0}.", commandString );
|
|
return;
|
|
}
|
|
else if ( e.Mobile.AccessLevel < command.AccessLevel )
|
|
{
|
|
e.Mobile.SendMessage( "You do not have access to that command: {0}.", commandString );
|
|
return;
|
|
}
|
|
else if ( !command.ValidateArgs( m_Scope, eventArgs[i] ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < commands.Length; ++i )
|
|
{
|
|
BaseCommand command = commands[i];
|
|
BatchCommand bc = (BatchCommand)m_BatchCommands[i];
|
|
|
|
if ( list.Count > 20 )
|
|
CommandLogging.Enabled = false;
|
|
|
|
ArrayList usedList;
|
|
|
|
if ( Utility.InsensitiveCompare( bc.Object, "Current" ) == 0 )
|
|
{
|
|
usedList = list;
|
|
}
|
|
else
|
|
{
|
|
Hashtable propertyChains = new Hashtable();
|
|
|
|
usedList = new ArrayList( list.Count );
|
|
|
|
for ( int j = 0; j < list.Count; ++j )
|
|
{
|
|
object obj = list[j];
|
|
|
|
if ( obj == null )
|
|
continue;
|
|
|
|
Type type = obj.GetType();
|
|
|
|
PropertyInfo[] chain = (PropertyInfo[])propertyChains[type];
|
|
|
|
string failReason = "";
|
|
|
|
if ( chain == null && !propertyChains.Contains( type ) )
|
|
propertyChains[type] = chain = Properties.GetPropertyInfoChain( e.Mobile, type, bc.Object, PropertyAccess.Read, ref failReason );
|
|
|
|
if ( chain == null )
|
|
continue;
|
|
|
|
PropertyInfo endProp = Properties.GetPropertyInfo( ref obj, chain, ref failReason );
|
|
|
|
if ( endProp == null )
|
|
continue;
|
|
|
|
try
|
|
{
|
|
obj = endProp.GetValue( obj, null );
|
|
|
|
if ( obj != null )
|
|
usedList.Add( obj );
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
command.ExecuteList( eventArgs[i], usedList );
|
|
|
|
if ( list.Count > 20 )
|
|
CommandLogging.Enabled = true;
|
|
|
|
command.Flush( e.Mobile, list.Count > 20 );
|
|
}
|
|
}
|
|
catch ( Exception ex )
|
|
{
|
|
e.Mobile.SendMessage( ex.Message );
|
|
}
|
|
}
|
|
|
|
public bool Run( Mobile from )
|
|
{
|
|
if ( m_Scope == null )
|
|
{
|
|
from.SendMessage( "You must select the batch command scope." );
|
|
return false;
|
|
}
|
|
else if ( m_Condition.Length > 0 && !m_Scope.SupportsConditionals )
|
|
{
|
|
from.SendMessage( "This command scope does not support conditionals." );
|
|
return false;
|
|
}
|
|
else if ( m_Condition.Length > 0 && !Utility.InsensitiveStartsWith( m_Condition, "where" ) )
|
|
{
|
|
from.SendMessage( "The condition field must start with \"where\"." );
|
|
return false;
|
|
}
|
|
|
|
string[] args = CommandSystem.Split( m_Condition );
|
|
|
|
m_Scope.Process( from, this, args );
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void Initialize()
|
|
{
|
|
CommandSystem.Register( "Batch", AccessLevel.Counselor, new CommandEventHandler( Batch_OnCommand ) );
|
|
}
|
|
|
|
[Usage( "Batch" )]
|
|
[Description( "Allows multiple commands to be run at the same time." )]
|
|
public static void Batch_OnCommand( CommandEventArgs e )
|
|
{
|
|
Batch batch = new Batch();
|
|
|
|
e.Mobile.SendGump( new BatchGump( e.Mobile, batch ) );
|
|
}
|
|
}
|
|
|
|
public class BatchCommand
|
|
{
|
|
private string m_Command;
|
|
private string m_Object;
|
|
|
|
public string Command
|
|
{
|
|
get{ return m_Command; }
|
|
set{ m_Command = value; }
|
|
}
|
|
|
|
public string Object
|
|
{
|
|
get{ return m_Object; }
|
|
set{ m_Object = value; }
|
|
}
|
|
|
|
public void GetDetails( out string command, out string argString, out string[] args )
|
|
{
|
|
int indexOf = m_Command.IndexOf( ' ' );
|
|
|
|
if ( indexOf >= 0 )
|
|
{
|
|
argString = m_Command.Substring( indexOf + 1 );
|
|
|
|
command = m_Command.Substring( 0, indexOf );
|
|
args = CommandSystem.Split( argString );
|
|
}
|
|
else
|
|
{
|
|
argString = "";
|
|
command = m_Command.ToLower();
|
|
args = new string[0];
|
|
}
|
|
}
|
|
|
|
public BatchCommand( string command, string obj )
|
|
{
|
|
m_Command = command;
|
|
m_Object = obj;
|
|
}
|
|
}
|
|
|
|
public class BatchGump : BaseGridGump
|
|
{
|
|
private Mobile m_From;
|
|
private Batch m_Batch;
|
|
|
|
public BatchGump( Mobile from, Batch batch ) : base( 30, 30 )
|
|
{
|
|
m_From = from;
|
|
m_Batch = batch;
|
|
|
|
Render();
|
|
}
|
|
|
|
public void Render()
|
|
{
|
|
AddNewPage();
|
|
|
|
/* Header */
|
|
AddEntryHeader( 20 );
|
|
AddEntryHtml( 180, Center( "Batch Commands" ) );
|
|
AddEntryHeader( 20 );
|
|
AddNewLine();
|
|
|
|
AddEntryHeader( 9 );
|
|
AddEntryLabel( 191, "Run Batch" );
|
|
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, 0 ), ArrowRightWidth, ArrowRightHeight );
|
|
AddNewLine();
|
|
|
|
AddBlankLine();
|
|
|
|
/* Scope */
|
|
AddEntryHeader( 20 );
|
|
AddEntryHtml( 180, Center( "Scope" ) );
|
|
AddEntryHeader( 20 );
|
|
AddNewLine();
|
|
|
|
AddEntryHeader( 9 );
|
|
AddEntryLabel( 191, m_Batch.Scope == null ? "Select Scope" : m_Batch.Scope.Accessors[0] );
|
|
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, 1 ), ArrowRightWidth, ArrowRightHeight );
|
|
AddNewLine();
|
|
|
|
AddBlankLine();
|
|
|
|
/* Condition */
|
|
AddEntryHeader( 20 );
|
|
AddEntryHtml( 180, Center( "Condition" ) );
|
|
AddEntryHeader( 20 );
|
|
AddNewLine();
|
|
|
|
AddEntryHeader( 9 );
|
|
AddEntryText( 202, 0, m_Batch.Condition );
|
|
AddEntryHeader( 9 );
|
|
AddNewLine();
|
|
|
|
AddBlankLine();
|
|
|
|
/* Commands */
|
|
AddEntryHeader( 20 );
|
|
AddEntryHtml( 180, Center( "Commands" ) );
|
|
AddEntryHeader( 20 );
|
|
|
|
for ( int i = 0; i < m_Batch.BatchCommands.Count; ++i )
|
|
{
|
|
BatchCommand bc = (BatchCommand)m_Batch.BatchCommands[i];
|
|
|
|
AddNewLine();
|
|
|
|
AddImageTiled( CurrentX, CurrentY, 9, 2, 0x24A8 );
|
|
AddImageTiled( CurrentX, CurrentY + 2, 2, EntryHeight + OffsetSize + EntryHeight - 4, 0x24A8 );
|
|
AddImageTiled( CurrentX, CurrentY + EntryHeight + OffsetSize + EntryHeight - 2, 9, 2, 0x24A8 );
|
|
AddImageTiled( CurrentX + 3, CurrentY + 3, 6, EntryHeight + EntryHeight - 4 - OffsetSize, HeaderGumpID );
|
|
|
|
IncreaseX( 9 );
|
|
AddEntryText( 202, 1+(i*2), bc.Command );
|
|
AddEntryHeader( 9, 2 );
|
|
|
|
AddNewLine();
|
|
|
|
IncreaseX( 9 );
|
|
AddEntryText( 202, 2+(i*2), bc.Object );
|
|
}
|
|
|
|
AddNewLine();
|
|
|
|
AddEntryHeader( 9 );
|
|
AddEntryLabel( 191, "Add New Command" );
|
|
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, 2 ), ArrowRightWidth, ArrowRightHeight );
|
|
|
|
FinishPage();
|
|
}
|
|
|
|
public override void OnResponse( NetState sender, RelayInfo info )
|
|
{
|
|
int type, index;
|
|
|
|
if ( !SplitButtonID( info.ButtonID, 1, out type, out index ) )
|
|
return;
|
|
|
|
TextRelay entry = info.GetTextEntry( 0 );
|
|
|
|
if ( entry != null )
|
|
m_Batch.Condition = entry.Text;
|
|
|
|
for ( int i = m_Batch.BatchCommands.Count - 1; i >= 0; --i )
|
|
{
|
|
BatchCommand sc = (BatchCommand)m_Batch.BatchCommands[i];
|
|
|
|
entry = info.GetTextEntry( 1 + (i * 2) );
|
|
|
|
if ( entry != null )
|
|
sc.Command = entry.Text;
|
|
|
|
entry = info.GetTextEntry( 2 + (i * 2) );
|
|
|
|
if ( entry != null )
|
|
sc.Object = entry.Text;
|
|
|
|
if ( sc.Command.Length == 0 && sc.Object.Length == 0 )
|
|
m_Batch.BatchCommands.RemoveAt( i );
|
|
}
|
|
|
|
switch ( type )
|
|
{
|
|
case 0: // main
|
|
{
|
|
switch ( index )
|
|
{
|
|
case 0: // run
|
|
{
|
|
m_Batch.Run( m_From );
|
|
break;
|
|
}
|
|
case 1: // set scope
|
|
{
|
|
m_From.SendGump( new BatchScopeGump( m_From, m_Batch ) );
|
|
return;
|
|
}
|
|
case 2: // add command
|
|
{
|
|
m_Batch.BatchCommands.Add( new BatchCommand( "", "" ) );
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_From.SendGump( new BatchGump( m_From, m_Batch ) );
|
|
}
|
|
}
|
|
|
|
public class BatchScopeGump : BaseGridGump
|
|
{
|
|
private Mobile m_From;
|
|
private Batch m_Batch;
|
|
|
|
public BatchScopeGump( Mobile from, Batch batch ) : base( 30, 30 )
|
|
{
|
|
m_From = from;
|
|
m_Batch = batch;
|
|
|
|
Render();
|
|
}
|
|
|
|
public void Render()
|
|
{
|
|
AddNewPage();
|
|
|
|
/* Header */
|
|
AddEntryHeader( 20 );
|
|
AddEntryHtml( 140, Center( "Change Scope" ) );
|
|
AddEntryHeader( 20 );
|
|
|
|
/* Options */
|
|
for ( int i = 0; i < BaseCommandImplementor.Implementors.Count; ++i )
|
|
{
|
|
BaseCommandImplementor impl = BaseCommandImplementor.Implementors[i];
|
|
|
|
if ( m_From.AccessLevel < impl.AccessLevel )
|
|
continue;
|
|
|
|
AddNewLine();
|
|
|
|
AddEntryLabel( 20 + OffsetSize + 140, impl.Accessors[0] );
|
|
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, i ), ArrowRightWidth, ArrowRightHeight );
|
|
}
|
|
|
|
FinishPage();
|
|
}
|
|
|
|
public override void OnResponse( NetState sender, RelayInfo info )
|
|
{
|
|
int type, index;
|
|
|
|
if ( SplitButtonID( info.ButtonID, 1, out type, out index ) )
|
|
{
|
|
switch ( type )
|
|
{
|
|
case 0:
|
|
{
|
|
if ( index < BaseCommandImplementor.Implementors.Count )
|
|
{
|
|
BaseCommandImplementor impl = BaseCommandImplementor.Implementors[index];
|
|
|
|
if ( m_From.AccessLevel >= impl.AccessLevel )
|
|
m_Batch.Scope = impl;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_From.SendGump( new BatchGump( m_From, m_Batch ) );
|
|
}
|
|
}
|
|
}
|