01748bc5f8
Adding dispose methods to AxiosFile objects Adding extended log to AxiosLog Fixing issue in CommandConsole where the first line would not be displayed Adding commands to commandconsole
2953 lines
106 KiB
C#
2953 lines
106 KiB
C#
#if WINDOWS
|
|
#region Using Statements
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Content;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using Microsoft.Xna.Framework.Input;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.IO;
|
|
using System.ComponentModel;
|
|
using System.Reflection;
|
|
using XNACC.BaseTypes;
|
|
using System.Diagnostics;
|
|
#endregion
|
|
|
|
/*
|
|
* CommandConsoleBase.cs
|
|
* (C) 2009-2011, James R. Twine of JRTwine Software, LLC
|
|
*
|
|
* *************************************************************************
|
|
* * THIS CODE IS PROVIDED WITH NO WARRANTY - YOU USE IT AT YOUR OWN RISK! *
|
|
* *************************************************************************
|
|
*
|
|
* This Code Originated With Code From the "XNA Console Component Sample" by Kevin Jurkowski.
|
|
* At The Time Of This Writing, The Original Code Was Available
|
|
* From: http://www.ziggyware.com/readarticle.php?article_id=163
|
|
* (But, Ziggyware Is No Longer There! :<)
|
|
*
|
|
* Changes, (C) 2009, James R. Twine of JRTwine Software, LLC
|
|
* Changes:
|
|
* Converted to XNA 3.0
|
|
* More input keys supported (Symbols, digits, etc.)
|
|
* Better(?) Way of extending supported commands and their handlers, parameters, help, etc.
|
|
* Slight Q&D colorizing of output to differenate commands and output
|
|
* Extracted keyboard-specific functionality into an iterface
|
|
* Command history
|
|
* Command completion
|
|
* Scrollable log/output
|
|
* Base class supports "standard" commands
|
|
* Support for "hidden" commands
|
|
* Customizable scalable drawing
|
|
* Custom functions (basically macros that support parameters)
|
|
* Binding commands/functions to <ALT>-Key combinations (when the console is closed)
|
|
*
|
|
* And possibly some other fun stuff...!
|
|
*
|
|
* More Changes, (C) 2010, James R. Twine of JRTwine Software, LLC
|
|
* Changes:
|
|
* Expanded key bindings to support <ALT/SHIFT/CTRL> modifiers
|
|
* Converted to XNA 4.0
|
|
* Graphics optimizations
|
|
*
|
|
* Still MORE Changes, (C) 2011, James R. Twine of JRTwine Software, LLC
|
|
* Changes:
|
|
* Additional ways to hook into command execution/handling
|
|
* Addition of dynamic Console Variables (cvars)
|
|
* Support for external managed functions that can manipulate cvars and do... just about anything
|
|
* Ability to lock-down functions, bindings and external functions (to prevent tampering with a released game)
|
|
* TODO: Wanna wrap command handlers into an "ICCCommand" interface...
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
//NA: XNACC currently is only supported on Windows due to the fact that SortedDictionary is not avaiable on WP7/Xbox 360
|
|
//NA: Seriously Microsoft?
|
|
|
|
/// <summary>Namespace that contains code related to the XNACC (CommandConsole) component</summary>
|
|
namespace XNACC.Console
|
|
{
|
|
/// <summary>Base functionality of the XNACC (CommandConsole) component</summary>
|
|
public class CommandConsoleBase : DrawableGameComponent
|
|
{
|
|
#region EventArgs Object
|
|
/// <summary>EA object for the CVarModified event</summary>
|
|
public class CVarModifiedEventArgs : EventArgs
|
|
{
|
|
/// <summary>The actual CVar for this event</summary>
|
|
public CVar Value
|
|
{
|
|
get;
|
|
protected set;
|
|
}
|
|
/// <summary>Constructor for this object</summary>
|
|
/// <param name="value">The cvar that has been modified</param>
|
|
public CVarModifiedEventArgs(CVar value)
|
|
{
|
|
Value = value;
|
|
return;
|
|
}
|
|
}
|
|
/// <summary>EA object for handling console command execution</summary>
|
|
public class CommandConsoleEventArgs : EventArgs
|
|
{
|
|
/// <summary>The actual command line being executed</summary>
|
|
public string CmdLine
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>Flag indicating if the command has been handled by an event handler; if true, no further processing is done on the command</summary>
|
|
public bool Handled
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>Constructor for this object</summary>
|
|
/// <param name="cmdLine">The command line being processed</param>
|
|
public CommandConsoleEventArgs( string cmdLine )
|
|
{
|
|
CmdLine = cmdLine;
|
|
Handled = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
#region Command Object
|
|
/// <summary>This object contains information on a single Command that the console understands.</summary>
|
|
protected class CmdObject : IComparable< CmdObject >
|
|
{
|
|
/// <summary>Default constructor for the Command Object</summary>
|
|
public CmdObject()
|
|
: this( String.Empty, String.Empty, null, false, String.Empty, 0, 0 )
|
|
{
|
|
return;
|
|
}
|
|
/// <summary>Constuct an instance of the Command Object</summary>
|
|
/// <param name="command">The command identifier (no whitespace, please)</param>
|
|
/// <param name="help">The (brief) help for this command</param>
|
|
/// <param name="cmdAction">The delegate method that fires when the command is encountered</param>
|
|
public CmdObject( string command, string help, Action<string []> cmdAction )
|
|
: this( command, help, cmdAction, false, String.Empty, 0, 0 )
|
|
{
|
|
return;
|
|
}
|
|
/// <summary>Constuct an instance of the Command Object</summary>
|
|
/// <param name="command">The command identifier (no whitespace, please)</param>
|
|
/// <param name="help">The (brief) help for this command</param>
|
|
/// <param name="cmdAction">The delegate method that fires when the command is encountered</param>
|
|
/// <param name="isSecret">Is this a secret command (not shown in the help information)</param>
|
|
public CmdObject( string command, string help, Action<string []> cmdAction, bool isSecret )
|
|
: this( command, help, cmdAction, isSecret, String.Empty, 0, 0 )
|
|
{
|
|
return;
|
|
}
|
|
/// <summary>Constuct an instance of the Command Object</summary>
|
|
/// <param name="command">The command identifier (no whitespace, please)</param>
|
|
/// <param name="help">The (brief) help for this command</param>
|
|
/// <param name="cmdAction">The delegate method that fires when the command is encountered</param>
|
|
/// <param name="isSecret">Is this a secret command (not shown in the help information)</param>
|
|
/// <param name="detailedHelp">The detailed help for this command</param>
|
|
public CmdObject( string command, string help, Action<string []> cmdAction, bool isSecret, string detailedHelp )
|
|
: this( command, help, cmdAction, isSecret, detailedHelp, 0, 0 )
|
|
{
|
|
return;
|
|
}
|
|
/// <summary>Constuct an instance of the Command Object</summary>
|
|
/// <param name="command">The command identifier (no whitespace, please)</param>
|
|
/// <param name="help">The (brief) help for this command</param>
|
|
/// <param name="cmdAction">The delegate method that fires when the command is encountered</param>
|
|
/// <param name="isSecret">Is this a secret command (not shown in the help information)</param>
|
|
/// <param name="detailedHelp">The detailed help for this command</param>
|
|
/// <param name="minParams">The minimum number of parameters for this command (0 == no minimum)</param>
|
|
/// <param name="maxParams">The maximum number of parameters for this command (0 == no maximum)</param>
|
|
public CmdObject( string command, string help, Action<string []> cmdAction, bool isSecret, string detailedHelp, int minParams, int maxParams )
|
|
{
|
|
Command = command;
|
|
CommandHelp = help;
|
|
if( cmdAction != null )
|
|
{
|
|
CmdEvent += cmdAction;
|
|
}
|
|
IsSecret = isSecret;
|
|
CommandHelpDetailed = detailedHelp;
|
|
MinParameters = minParams;
|
|
MaxParameters = maxParams;
|
|
|
|
return;
|
|
|
|
}
|
|
/// <summary>Required - The command (single word, no spaces, and all commands will be converted to lowercase)</summary>
|
|
public String Command { get; set; }
|
|
|
|
/// <summary>Optional - Summary help information that briefly describes the command</summary>
|
|
public String CommandHelp { get; set; }
|
|
|
|
/// <summary>Optional - Detailed help information that explains the command and its usage</summary>
|
|
public String CommandHelpDetailed { get; set; }
|
|
|
|
/// <summary>The minimum number of parameters the command expects (set to zero for no minimum)</summary>
|
|
public int MinParameters { get; set; }
|
|
|
|
/// <summary>The maximum number of parameters the command expects (set to zero for no maximum)</summary>
|
|
public int MaxParameters { get; set; }
|
|
|
|
/// <summary>Indicates if this command is secret -- if so, it will not appear when the user types
|
|
/// "help" and will not participate in command completion</summary>
|
|
public bool IsSecret { get; set; }
|
|
|
|
/// <summary>The event fired when the associated command is received</summary>
|
|
public event Action<string[]> CmdEvent;
|
|
|
|
/// <summary>This method fires the associated Delegate</summary>
|
|
/// <param name="cmdLine">The complete command line. Not just the command's parameters!</param>
|
|
/// <remarks>This method is public to allow for artificial triggering of commands.</remarks>
|
|
public void TriggerEvent( String[] cmdLine )
|
|
{
|
|
if( CmdEvent != null )
|
|
{
|
|
CmdEvent.Invoke( cmdLine );
|
|
}
|
|
}
|
|
#region IComparable<CmdObject> Members
|
|
|
|
/// <summary>Compare this object with another object instance</summary>
|
|
/// <param name="other">The object to compare to</param>
|
|
/// <returns>The result of comparing the object's Command strings</returns>
|
|
public int CompareTo( CmdObject other )
|
|
{
|
|
return( Command.CompareTo( other.Command ) );
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Function Object
|
|
/// <summary>This object contains information on a custom function that the console understands.</summary>
|
|
protected class FuncObject : IComparable< FuncObject >
|
|
{
|
|
/// <summary>The function name</summary>
|
|
public String Function
|
|
{
|
|
get;
|
|
protected set;
|
|
}
|
|
/// <summary>The code to execute when the function executes</summary>
|
|
public IList<String> FunctionImpl
|
|
{
|
|
get;
|
|
protected set;
|
|
}
|
|
/// <summary>Constructor for the Function Object</summary>
|
|
/// <param name="funcName">The name of the Function</param>
|
|
/// <param name="funcImpl">The implementation of the Function</param>
|
|
public FuncObject( string funcName, string[] funcImpl )
|
|
{
|
|
if( String.IsNullOrWhiteSpace( funcName ) )
|
|
{
|
|
throw new ArgumentException( "The function name must not be whitespace.", "funcName" );
|
|
}
|
|
Function = funcName.Trim().ToLowerInvariant();
|
|
FunctionImpl = new List<string>( funcImpl );
|
|
|
|
return;
|
|
}
|
|
/// <summary>Indicates if this function is secret -- it will not appear when the user types "help"</summary>
|
|
public bool IsSecret
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>Provide a string representation of this object</summary>
|
|
/// <returns>A string containing a representation of the object</returns>
|
|
public override string ToString()
|
|
{
|
|
StringBuilder sbCmdLine = new StringBuilder( FunctionImpl.Count * 32 );
|
|
|
|
foreach( string line in FunctionImpl )
|
|
{
|
|
if( sbCmdLine.Length > 0 )
|
|
{
|
|
sbCmdLine.Append( "; " );
|
|
}
|
|
sbCmdLine.Append( line );
|
|
}
|
|
return ( String.Format( "{0} -> {1}", Function, sbCmdLine.ToString() ) );
|
|
}
|
|
|
|
#region IComparable<FuncObject> Members
|
|
|
|
/// <summary>Compare this object with another object instance</summary>
|
|
/// <param name="other">The object to compare to</param>
|
|
/// <returns>The result of comparing the object's Function strings</returns>
|
|
public int CompareTo( FuncObject other )
|
|
{
|
|
return( Function.CompareTo( other.Function ) );
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region External Function Object
|
|
/// <summary>This object contains information on an external function (implemented in a .NET assembly) that the console understands.</summary>
|
|
protected class ExternalFuncObject : IComparable<ExternalFuncObject>
|
|
{
|
|
/// <summary>Collection Of Known Class Instances</summary>
|
|
static protected Dictionary< string, object > ms_classInstances = new Dictionary<string,object>( 8 );
|
|
|
|
/// <summary>The method name</summary>
|
|
public String MethodName
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>Is this external function secret?</summary>
|
|
public bool IsSecret
|
|
{
|
|
get;
|
|
protected set;
|
|
}
|
|
/// <summary>Command line used to create the function</summary>
|
|
public String CommandLine
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The actual method metadata</summary>
|
|
protected MethodInfo m_method;
|
|
/// <summary>The actual class instance</summary>
|
|
protected object m_classInstance;
|
|
/// <summary>Construct an instance of this object, storing information on the specified method</summary>
|
|
/// <param name="assembly">The name/path of the assembly/DLL to load from</param>
|
|
/// <param name="className">The fully qualified, case-sensitive class name</param>
|
|
/// <param name="methodName">The case-sensitive name of the method to get</param>
|
|
public ExternalFuncObject( string assembly, string className, string methodName )
|
|
: this( assembly, className, methodName, false )
|
|
{
|
|
return;
|
|
}
|
|
/// <summary>Construct an instance of this object, storing information on the specified method</summary>
|
|
/// <param name="assembly">The name/path of the assembly/DLL to load from</param>
|
|
/// <param name="className">The fully qualified, case-sensitive class name</param>
|
|
/// <param name="methodName">The case-sensitive name of the method to get</param>
|
|
/// <param name="isSecret">Is this a secret/hidden ExFunc?</param>
|
|
public ExternalFuncObject( string assembly, string className, string methodName, bool isSecret )
|
|
{
|
|
Type classType = null;
|
|
|
|
// See If We Already Have An Instance Of This Class
|
|
if( ms_classInstances.TryGetValue( className,
|
|
out m_classInstance ) == false )
|
|
{ // We Do Not, So Create And Store One
|
|
|
|
Assembly asm = null;
|
|
|
|
try
|
|
{
|
|
asm = Assembly.LoadFrom( assembly );
|
|
}
|
|
catch( FileNotFoundException )
|
|
{
|
|
asm = Assembly.LoadFrom( assembly + ".dll" );
|
|
}
|
|
classType = asm.GetType( className, false );
|
|
if( classType == null )
|
|
{
|
|
classType = asm.GetType( assembly + "." + className, true );
|
|
}
|
|
m_classInstance = Activator.CreateInstance( classType );
|
|
ms_classInstances[ methodName ] = m_classInstance;
|
|
}
|
|
// Store Name Of Method And
|
|
MethodName = methodName;
|
|
m_method = classType.GetMethod( methodName );
|
|
IsSecret = isSecret;
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>Attempt to invoke the previously loaded method dynamically</summary>
|
|
/// <param name="parameters">Parameters that should be passed to the method, or null if none</param>
|
|
/// <returns>A string return value from the method, or String.Empty if a null is returned or if the method returns void</returns>
|
|
public string Invoke( params object[] parameters )
|
|
{
|
|
string ret;
|
|
|
|
try
|
|
{
|
|
object returnVal = m_method.Invoke( m_classInstance, parameters );
|
|
|
|
ret = ( returnVal != null ) ? returnVal.ToString() : String.Empty;
|
|
}
|
|
catch( Exception ex )
|
|
{
|
|
ret = ex.Message;
|
|
}
|
|
return( ret );
|
|
}
|
|
/// <summary>Provide a string representation of this object</summary>
|
|
/// <returns>A string containing a representation of the object</returns>
|
|
public override string ToString()
|
|
{
|
|
return ( String.Format( "{0}::{1}", m_classInstance, MethodName ) );
|
|
}
|
|
#region IComparable<FuncObject> Members
|
|
|
|
/// <summary>Compare this object with another object instance</summary>
|
|
/// <param name="other">The object to compare to</param>
|
|
/// <returns>The result of comparing the object's MethodName strings</returns>
|
|
public int CompareTo( ExternalFuncObject other )
|
|
{
|
|
return ( MethodName.CompareTo( other.MethodName ) );
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Binding Object
|
|
/// <summary>This object stores information on a bound key</summary>
|
|
protected class BindingObject : IComparable< BindingObject >
|
|
{
|
|
/// <summary>Modifier keys for this key-binding</summary>
|
|
[Flags]
|
|
public enum EModifier
|
|
{
|
|
/// <summary>No modifier keys associated with this Binding</summary>
|
|
None = 0,
|
|
/// <summary>CTRL modifier key is associated with this Binding</summary>
|
|
Ctrl = 1,
|
|
/// <summary>SHIFT modifier key is associated with this Binding</summary>
|
|
Shift = 2,
|
|
/// <summary>ALT modifier key is associated with this Binding</summary>
|
|
Alt = 4,
|
|
}
|
|
/// <summary>The command/function to execute when the bound key is hit</summary>
|
|
public string _text;
|
|
/// <summary>The key that the command/function is bound to</summary>
|
|
public Keys _key;
|
|
/// <summary>The modifier key for _key (Ctrl, Alt, Shift) - modifiers use the LEFT version of the key identifier</summary>
|
|
public EModifier _modifierKeys;
|
|
/// <summary>Gets the modifier key(s) in human readable form</summary>
|
|
/// <returns>A string representing this binding's modifiers, or an empty string if none</returns>
|
|
public string GetModifierString()
|
|
{
|
|
StringBuilder sb = new StringBuilder( 32 );
|
|
bool usesCtrl = ( ( _modifierKeys & EModifier.Ctrl ) == EModifier.Ctrl );
|
|
bool usesShift = ( ( _modifierKeys & EModifier.Shift ) == EModifier.Shift );
|
|
bool usesAlt = ( ( _modifierKeys & EModifier.Alt ) == EModifier.Alt );
|
|
bool first = false;
|
|
|
|
if( usesCtrl )
|
|
{
|
|
sb.Append( "CTRL" );
|
|
first = false;
|
|
}
|
|
if( usesAlt )
|
|
{
|
|
if( !first )
|
|
{
|
|
sb.Append( '+' );
|
|
}
|
|
sb.Append( "ALT" );
|
|
}
|
|
if( usesShift )
|
|
{
|
|
if( !first )
|
|
{
|
|
sb.Append( '+' );
|
|
}
|
|
sb.Append( "SHIFT" );
|
|
}
|
|
if( sb.Length > 0 )
|
|
{
|
|
sb.Append( '+' );
|
|
}
|
|
return( sb.ToString() );
|
|
}
|
|
/// <summary>Convert this binding object into an informational string</summary>
|
|
/// <returns>The informational string</returns>
|
|
public override string ToString()
|
|
{
|
|
return ( String.Format( "<{0}{1}> -> {2}", GetModifierString(), _key, _text ) );
|
|
}
|
|
|
|
#region IComparable<BindingObject> Members
|
|
|
|
/// <summary>Compare this object with another object instance</summary>
|
|
/// <param name="other">The object to compare to</param>
|
|
/// <returns>Nothing - Not Implemented Yet</returns>
|
|
public int CompareTo( BindingObject other )
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Fields
|
|
#region Command Processing
|
|
// -- Command Processing-Related Fields...
|
|
/// <summary>Collection Of Command Objects.</summary>
|
|
protected SortedDictionary<string,CmdObject> ms_commands = new SortedDictionary<string, CmdObject>();
|
|
/// <summary>Collection Of function Objects.</summary>
|
|
protected SortedDictionary<string, FuncObject> ms_functions = new SortedDictionary<string, FuncObject>();
|
|
/// <summary>Collection Of External Functions.</summary>
|
|
protected SortedDictionary<string, ExternalFuncObject> ms_externalFunctions = new SortedDictionary<string, ExternalFuncObject>();
|
|
/// <summary>Collection Of Binding Objects.</summary>
|
|
protected List<BindingObject> ms_bindings = new List<BindingObject>( 8 );
|
|
|
|
/// <summary>Colleciton Of Partial Command Matches</summary>
|
|
protected List<string> ms_partialCmdMatches = new List<string>( 8 );
|
|
/// <summary>Symbol table for the console variables</summary>
|
|
protected Dictionary<string, CVar> m_cVars = new Dictionary<string, CVar>( 8 );
|
|
/// <summary>Match index for the last partial command</summary>
|
|
protected int m_cmdMatchIndex = 0;
|
|
/// <summary>The last command match found</summary>
|
|
protected string m_lastCmdMatch = String.Empty;
|
|
/// <summary>The command line itself</summary>
|
|
protected string m_commandLine = String.Empty;
|
|
|
|
/// <summary>Function-related functions are locked out</summary>
|
|
protected bool m_functionsLocked = false;
|
|
/// <summary>Binding-related functions are locked out</summary>
|
|
protected bool m_bindingsLocked = false;
|
|
/// <summary>External-Function-related functions are locked out</summary>
|
|
protected bool m_exfunsLocked = false;
|
|
#endregion
|
|
|
|
#region Drawing and Graphics
|
|
// -- Drawing/Graphics-Related Fields...
|
|
/// <summary>Drawing object</summary>
|
|
protected SpriteBatch m_spriteBatch;
|
|
/// <summary>Font used for drawing the console's text</summary>
|
|
protected SpriteFont m_consoleFont;
|
|
/// <summary>Rectangle for the console area</summary>
|
|
protected Rectangle m_consoleRect;
|
|
/// <summary>Location of the command line</summary>
|
|
protected Vector2 m_commandPos;
|
|
/// <summary>Hight for the current console font</summary>
|
|
protected Vector2 m_stringHeight;
|
|
/// <summary>Offset for the command line</summary>
|
|
protected float m_commandStringHeightOffset;
|
|
/// <summary>Number of characters that can fit in the console area's width</summary>
|
|
protected int m_screenCharWidth;
|
|
/// <summary>Width of the console area</summary>
|
|
protected int m_width;
|
|
/// <summary>Height of the console area</summary>
|
|
protected int m_height;
|
|
/// <summary>Scale for drawing the console</summary>
|
|
protected float m_scale = 1.0f;
|
|
#endregion
|
|
|
|
#region Scrolling and Logging
|
|
// -- Scrolling-Related Fields...
|
|
/// <summary>The number of lines that are visible in the console area</summary>
|
|
protected int m_linesVisibleOnScreen;
|
|
/// <summary>Used for drawing an indicator to show that lines are scrolled above</summary>
|
|
protected bool m_linesAbove;
|
|
/// <summary>Used for drawing an indicator to show that lines are scrolled below</summary>
|
|
protected bool m_linesBelow;
|
|
/// <summary>Where the log starts at (for scrolling)</summary>
|
|
protected int m_logStart = 0;
|
|
/// <summary>Specifies the limit of the log buffer</summary>
|
|
protected int m_logLimit = 512;
|
|
|
|
// -- Logging-Related Fields...
|
|
/// <summary>The path to the log shadow (copy of all logged lines)</summary>
|
|
protected string m_logShadowFilePath = String.Empty;
|
|
/// <summary>Flag indicating that the log is being shadowed</summary>
|
|
protected bool m_logShadowEnabled = false;
|
|
/// <summary>The stream for shadowing the log to</summary>
|
|
protected StreamWriter m_logShadowFile = null;
|
|
/// <summary>Storage for the log</summary>
|
|
protected static List<string> m_log = new List<string>( 256 );
|
|
#endregion
|
|
|
|
#region Command History
|
|
// Command History-Related Fields
|
|
/// <summary>Specifies the limit of the command history</summary>
|
|
protected int m_cmdHistoryLimit = 512;
|
|
/// <summary>Collection of command history</summary>
|
|
protected static List<string> m_cmdHistory = new List<string>( 128 );
|
|
/// <summary>Current index in the command history</summary>
|
|
protected int m_cmdHistoryIndex = 0;
|
|
/// <summary>Scanning (up/down) index in of the command history</summary>
|
|
protected int m_cmdHistoryScanIndex = 0;
|
|
#endregion
|
|
|
|
#region Input Processing
|
|
// Input related fields
|
|
/// <summary>Time for key repeat</summary>
|
|
protected DateTime m_keyRepeatTime = DateTime.MinValue;
|
|
/// <summary>Character translation for ALL keyboard keys - contains an element for all values in the Keys enumeration</summary>
|
|
protected List<String> m_xlateAllKeys;
|
|
/// <summary>Character translation for ALL keyboard keys, shifted - contains an element for all values in the Keys enumeration</summary>
|
|
protected List<String> m_xlateAllKeysShifted;
|
|
#endregion
|
|
#endregion
|
|
|
|
#region Events
|
|
/// <summary>Event fired right before handling/execution of a command. Allows interception of normal command processing.</summary>
|
|
public event EventHandler<CommandConsoleEventArgs> PreCommandExecutedEvent;
|
|
/// <summary>Event fired when a console variable has been created/modified</summary>
|
|
public event EventHandler<CVarModifiedEventArgs> CVarModifiedEvent;
|
|
#endregion
|
|
|
|
#region Properties
|
|
/// <summary>Interface to the keyboard used for console input</summary>
|
|
public IConsoleKeyboard Keyboard
|
|
{
|
|
get;
|
|
protected set;
|
|
}
|
|
/// <summary>Image/Texture used to fade the text underneath the console's text area</summary>
|
|
public Texture2D FadeImage
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The color used to produce the fade</summary>
|
|
public Color FadeColor
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>Drawing scale for the console</summary>
|
|
public float Scale
|
|
{
|
|
get
|
|
{
|
|
return m_scale;
|
|
}
|
|
set
|
|
{
|
|
m_scale = value;
|
|
m_stringHeight = Vector2.Zero;
|
|
}
|
|
}
|
|
|
|
/// <summary>Indicates if the console is active or not</summary>
|
|
public static bool Active
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The prompt shown for the command line</summary>
|
|
public string Prompt
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The color used to display entered commands</summary>
|
|
public Color CommandColor
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The color used to display error messages</summary>
|
|
public Color ErrorColor
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The color used to display output from executed commands</summary>
|
|
public Color OutputColor
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The color used to display "normal" output messages</summary>
|
|
public Color NormalColor
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
/// <summary>The font used for text display</summary>
|
|
public SpriteFont Font
|
|
{
|
|
get { return( m_consoleFont ); }
|
|
set
|
|
{
|
|
m_consoleFont = value;
|
|
m_stringHeight = Vector2.Zero;
|
|
}
|
|
}
|
|
/// <summary>Sets/Gets the height of the console window</summary>
|
|
public int Height
|
|
{
|
|
get
|
|
{
|
|
return( m_height );
|
|
}
|
|
set
|
|
{
|
|
m_height = value;
|
|
m_stringHeight = Vector2.Zero;
|
|
}
|
|
}
|
|
/// <summary>Sets/Gets the width of the console window</summary>
|
|
public int Width
|
|
{
|
|
get
|
|
{
|
|
return( m_width );
|
|
}
|
|
set
|
|
{
|
|
m_width = value;
|
|
m_stringHeight = Vector2.Zero;
|
|
}
|
|
}
|
|
#endregion
|
|
#region Initialization
|
|
/// <summary>Constructor for this base class</summary>
|
|
/// <param name="game">The Game object for the owning/managing game</param>
|
|
public CommandConsoleBase( Game game )
|
|
: this( game, null )
|
|
{
|
|
return;
|
|
}
|
|
/// <summary>Constructor for this base class</summary>
|
|
/// <param name="game">The Game object for the owning/managing game</param>
|
|
/// <param name="fontToUse">The font that the console should use to draw its text</param>
|
|
public CommandConsoleBase( Game game, SpriteFont fontToUse )
|
|
: base( game )
|
|
{
|
|
m_consoleFont = fontToUse;
|
|
Prompt = "_>";
|
|
CommandColor = Color.SteelBlue;
|
|
ErrorColor = Color.Firebrick;
|
|
OutputColor = Color.Yellow;
|
|
NormalColor = Color.Silver;
|
|
|
|
return;
|
|
}
|
|
/// <summary>Primary initialization function</summary>
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
// OK - This Seems Very Heavyweight, And It Kinda Is. But It Allows For
|
|
// Easy Mapping Of A "Keys" Value To Any String, Which Makes It Possible
|
|
// To Create Single Key Macros, Like Binding On Steroids, And Also Makes
|
|
// It Easy To Handle Non-US Or Gaming Keyboards.
|
|
|
|
// The Format Of The Lines Below Is A Comment Line That Identifies The Array
|
|
// Indices, Which Correspond To Values In The "Keys" Enumeration, And Then
|
|
// The Actual Values For Those Indices.
|
|
m_xlateAllKeys = new List<String>( new[] {
|
|
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
|
|
" ", "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 48 49 50 51 52 53 54 55 56 57 58 59 60 61 63 63
|
|
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "" , "" , "" , "" , "" , "" ,
|
|
// 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
|
|
"" , "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
|
|
// 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
|
|
"p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "" , "" , "" , "" , "" ,
|
|
// 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
|
|
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "+", ",", "-", ".", "/",
|
|
// 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 144 145 146 147 148 149 150 151 152 153 154 155 156 157 159 159
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , ";", "=", ",", "-", ".", "/",
|
|
// 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
|
|
"", "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "[", "\\","]", "'", "8",
|
|
// 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
|
|
"" , "" ,"|", "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
} );
|
|
|
|
// Create Collection Of Characters (Strings) For All Possible SHIFTED Key Values...
|
|
m_xlateAllKeysShifted = new List<String>( new[] {
|
|
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
|
|
" ", "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 48 49 50 51 52 53 54 55 56 57 58 59 60 61 63 63
|
|
")", "!", "@", "#", "$", "%", "^", "&", "*", "(", "" , "" , "" , "" , "" , "" ,
|
|
// 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
|
|
"" , "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
|
|
// 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
|
|
"P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "" , "" , "" , "" , "" ,
|
|
// 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
|
|
"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "+", ",", "-", ".", "/",
|
|
// 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 144 145 146 147 148 149 150 151 152 153 154 155 156 157 159 159
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , ":", "+", "<", "_", ">", "?",
|
|
// 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
|
|
"", "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "{", "|", "}","\"", "*",
|
|
// 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
|
|
"" , "" ,"\\", "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
// 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
|
|
"" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" , "" ,
|
|
} );
|
|
return;
|
|
}
|
|
#endregion
|
|
#region Graphics Content
|
|
/// <summary>Load content for this component</summary>
|
|
/// <param name="content">The ContentManager that should be used </param>
|
|
public virtual void LoadContent( ContentManager content )
|
|
{
|
|
m_spriteBatch = new SpriteBatch( GraphicsDevice );
|
|
|
|
m_width = GraphicsDevice.Viewport.Width;
|
|
m_height = ( GraphicsDevice.Viewport.Height / 3 );
|
|
|
|
InitializeCommands();
|
|
base.LoadContent();
|
|
|
|
return;
|
|
}
|
|
#endregion
|
|
|
|
#region Update and Draw
|
|
/// <summary>
|
|
/// Recalculates measurements required for text display and wrapping. Sets the m_consoleRect,
|
|
/// m_commandPos and m_linesVisibleOnScreen fields.
|
|
/// </summary>
|
|
protected virtual void RecalculateHeightSettings()
|
|
{
|
|
m_consoleRect = new Rectangle( 0, 0, m_width, m_height );
|
|
m_commandPos = new Vector2( 10.0f, m_height - m_commandStringHeightOffset );
|
|
m_linesVisibleOnScreen = ( (int)( m_height / m_stringHeight.Y ) - 1 );
|
|
|
|
return;
|
|
}
|
|
/// <summary>Update this component</summary>
|
|
/// <param name="gameTime">Game's time</param>
|
|
public override void Update( GameTime gameTime )
|
|
{
|
|
CheckInput();
|
|
|
|
base.Update( gameTime );
|
|
}
|
|
/// <summary>Draw the console</summary>
|
|
/// <param name="gameTime">Game's time</param>
|
|
public override void Draw( GameTime gameTime )
|
|
{
|
|
m_linesAbove = m_linesBelow = false;
|
|
|
|
if( Active == true )
|
|
{
|
|
m_spriteBatch.Begin( SpriteSortMode.Deferred, BlendState.AlphaBlend );
|
|
|
|
if( FadeImage != null )
|
|
{
|
|
// Fade The Console Area With The Specified Texture/Image...
|
|
m_spriteBatch.Draw( FadeImage, m_consoleRect, FadeColor );
|
|
}
|
|
//
|
|
// Cache Pre-Calculatable Values...
|
|
//
|
|
if( m_stringHeight == Vector2.Zero )
|
|
{
|
|
m_stringHeight = Vector2.Multiply( m_consoleFont.MeasureString( Prompt ), Scale );
|
|
m_screenCharWidth = (int)( ( m_width / m_stringHeight.X ) * 2 );
|
|
m_commandStringHeightOffset = ( ( m_stringHeight.Y * 2.0f ) - 4.0f );
|
|
RecalculateHeightSettings();
|
|
}
|
|
// Draw command string
|
|
m_spriteBatch.DrawString( m_consoleFont, Prompt + m_commandLine,
|
|
m_commandPos, Color.Yellow, 0.0f, Vector2.Zero,
|
|
Scale, SpriteEffects.None, 0.0f );
|
|
|
|
// Draw log
|
|
Vector2 linePos = new Vector2( m_consoleRect.Left + 10.0f, ( m_commandPos.Y - m_stringHeight.Y ) );
|
|
|
|
int endLine = Math.Max( 0, ( ( m_log.Count - m_logStart ) - 1 ) );
|
|
|
|
if( m_logStart != 0 )
|
|
{
|
|
m_linesBelow = true;
|
|
}
|
|
for( int i = endLine; i >= 0; i-- )
|
|
{
|
|
if( linePos.Y <= m_consoleRect.Top )
|
|
{
|
|
m_linesAbove = true;
|
|
break;
|
|
}
|
|
String line = m_log[ i ];
|
|
|
|
if( line.Length == 0 )
|
|
{
|
|
continue;
|
|
}
|
|
Char firstChar = line[ 0 ];
|
|
|
|
if( firstChar <= '\x03' )
|
|
{
|
|
Color outColor = OutputColor;
|
|
|
|
if( firstChar == '\x01' )
|
|
{
|
|
outColor = CommandColor;
|
|
}
|
|
else if( firstChar == '\x02' )
|
|
{
|
|
outColor = ErrorColor;
|
|
}
|
|
else if( firstChar == '\x03' )
|
|
{
|
|
outColor = OutputColor;
|
|
}
|
|
m_spriteBatch.DrawString( m_consoleFont, line.Substring( 1 ),
|
|
linePos, outColor, 0.0f, Vector2.Zero, Scale,
|
|
SpriteEffects.None, 0.0f );
|
|
}
|
|
else
|
|
{
|
|
m_spriteBatch.DrawString( m_consoleFont, line, linePos,
|
|
NormalColor, 0.0f, Vector2.Zero, Scale,
|
|
SpriteEffects.None, 0.0f );
|
|
}
|
|
linePos.Y -= m_stringHeight.Y;
|
|
}
|
|
if( m_linesAbove )
|
|
{
|
|
Vector2 starPos = new Vector2( m_width - 10.0f, m_consoleRect.Top );
|
|
|
|
m_spriteBatch.DrawString( m_consoleFont, "^", starPos,
|
|
ErrorColor, 0.0f, Vector2.Zero, Scale,
|
|
SpriteEffects.None, 0.0f );
|
|
}
|
|
if( m_linesBelow )
|
|
{
|
|
Vector2 starPos = new Vector2( m_width - 10.0f, ( m_commandPos.Y - m_stringHeight.Y ) );
|
|
|
|
m_spriteBatch.DrawString( m_consoleFont, "V", starPos,
|
|
ErrorColor, 0.0f, Vector2.Zero, Scale,
|
|
SpriteEffects.None, 0.0f );
|
|
}
|
|
m_spriteBatch.End();
|
|
}
|
|
base.Draw( gameTime );
|
|
|
|
return;
|
|
}
|
|
#endregion
|
|
|
|
#region Input Handling
|
|
/// <summary>Process a keyboard key. Assumes that the Keyboard property is not null!</summary>
|
|
/// <param name="key">The key to process</param>
|
|
protected virtual void ProcessKey( Keys key )
|
|
{
|
|
// Space - Special Handling To Eliminate Leading Whitespace
|
|
if( ( key == Keys.Space ) && ( !String.IsNullOrWhiteSpace( m_commandLine ) ) )
|
|
{
|
|
m_commandLine += " ";
|
|
ms_partialCmdMatches.Clear();
|
|
m_lastCmdMatch = String.Empty;
|
|
}
|
|
// Command History...
|
|
else if( key == Keys.Up )
|
|
{
|
|
if( m_cmdHistory.Count == 0 )
|
|
{
|
|
return;
|
|
}
|
|
m_cmdHistoryScanIndex--;
|
|
if( m_cmdHistoryScanIndex < 0 )
|
|
{
|
|
m_cmdHistoryScanIndex = 0;
|
|
}
|
|
m_commandLine = m_cmdHistory[ m_cmdHistoryScanIndex ];
|
|
ms_partialCmdMatches.Clear();
|
|
}
|
|
else if( key == Keys.Down )
|
|
{
|
|
if( m_cmdHistory.Count == 0 )
|
|
{
|
|
return;
|
|
}
|
|
m_cmdHistoryScanIndex++;
|
|
if( m_cmdHistoryScanIndex >= m_cmdHistory.Count )
|
|
{
|
|
m_cmdHistoryScanIndex = ( m_cmdHistory.Count - 1 );
|
|
}
|
|
m_commandLine = m_cmdHistory[ m_cmdHistoryScanIndex ];
|
|
ms_partialCmdMatches.Clear();
|
|
}
|
|
// Log Scrolling...
|
|
else if( ( key == Keys.PageUp ) && ( m_linesVisibleOnScreen < m_log.Count ) )
|
|
{
|
|
m_logStart += ( m_linesVisibleOnScreen - 1 );
|
|
if( m_logStart >= ( m_log.Count - m_linesVisibleOnScreen ) )
|
|
{
|
|
m_logStart = ( m_log.Count - m_linesVisibleOnScreen + 1 );
|
|
}
|
|
}
|
|
else if( ( key == Keys.PageDown ) && ( m_linesVisibleOnScreen < m_log.Count ) )
|
|
{
|
|
m_logStart -= ( m_linesVisibleOnScreen - 1 );
|
|
if( m_logStart < 0 )
|
|
{
|
|
m_logStart = 0;
|
|
}
|
|
}
|
|
// Check input for Escape
|
|
else if( key == Keys.Escape )
|
|
{
|
|
m_commandLine = String.Empty;
|
|
ms_partialCmdMatches.Clear();
|
|
m_lastCmdMatch = String.Empty;
|
|
}
|
|
// Check input for Backspace
|
|
else if( ( key == Keys.Back ) && ( !String.IsNullOrEmpty( m_commandLine ) ) &&
|
|
( m_commandLine != Prompt ) )
|
|
{
|
|
m_commandLine = m_commandLine.Remove( m_commandLine.Length - 1, 1 );
|
|
ms_partialCmdMatches.Clear();
|
|
m_lastCmdMatch = String.Empty;
|
|
}
|
|
// Check input for Tab
|
|
else if( ( key == Keys.Tab ) && ( !String.IsNullOrEmpty( m_commandLine ) ) &&
|
|
( m_commandLine != Prompt ) )
|
|
{
|
|
// Rebuild Partial Command Matches If List Is Empty/Reset
|
|
if( ms_partialCmdMatches.Count == 0 )
|
|
{
|
|
BuildCommandMatches( m_commandLine );
|
|
m_cmdMatchIndex = 0;
|
|
}
|
|
// If We Have Partial Matches, Circularly Iterate Over Them And Show Them
|
|
if( ms_partialCmdMatches.Count > 0 )
|
|
{
|
|
if( m_cmdMatchIndex >= ms_partialCmdMatches.Count )
|
|
{
|
|
m_cmdMatchIndex = 0;
|
|
}
|
|
m_commandLine = ms_partialCmdMatches[ m_cmdMatchIndex++ ];
|
|
}
|
|
}
|
|
// Enter - Commit Command Line
|
|
else if( ( key == Keys.Enter ) && ( !String.IsNullOrWhiteSpace( m_commandLine ) ) )
|
|
{
|
|
AddToLog( "\x01" + m_commandLine );
|
|
m_logStart = 0;
|
|
ExecuteCommandLine( true );
|
|
m_commandLine = String.Empty;
|
|
}
|
|
// Any Other Key, Process As Character (Even If Not A Real Character Key)
|
|
else
|
|
{
|
|
// Handle Shifted Chars
|
|
if( ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.LeftShift ) ) ||
|
|
( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.RightShift ) ) )
|
|
{
|
|
m_commandLine += m_xlateAllKeysShifted[ (int)key ];
|
|
}
|
|
else
|
|
{
|
|
m_commandLine += m_xlateAllKeys[ (int)key ];
|
|
}
|
|
ms_partialCmdMatches.Clear();
|
|
m_lastCmdMatch = String.Empty;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>Check input from the provided keyboard interface</summary>
|
|
protected virtual void CheckInput()
|
|
{
|
|
//InputManager im = InputManager.Instance;
|
|
|
|
// If No Interface To The Keyboard, Stop Here
|
|
if( Keyboard == null )
|
|
{
|
|
return;
|
|
}
|
|
// Toggle the console menu on or off
|
|
if( Keyboard.NewlyPressedKeys.Contains( Keys.OemTilde ) )
|
|
{
|
|
Active = !Active;
|
|
return;
|
|
}
|
|
// Only Check Bindings If The Console Is Not Active
|
|
if( Active == false )
|
|
{
|
|
CheckBindings();
|
|
return;
|
|
}
|
|
if( Keyboard.HeldKeys.Count > 0 )
|
|
{
|
|
if( DateTime.Now > m_keyRepeatTime )
|
|
{
|
|
ProcessKey( Keyboard.HeldKeys[ 0 ] );
|
|
m_keyRepeatTime = DateTime.Now.AddMilliseconds( 100 );
|
|
}
|
|
}
|
|
if( Keyboard.NewlyPressedKeys.Count > 0 )
|
|
{
|
|
ProcessKey( Keyboard.NewlyPressedKeys[ 0 ] );
|
|
m_keyRepeatTime = DateTime.Now.AddMilliseconds( 250 );
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>Get binding information from a "binding string" input by the user</summary>
|
|
/// <param name="bindString">The binding string to parse</param>
|
|
/// <param name="bindModifiers">ref - the modifier keys for the binding</param>
|
|
/// <param name="bindKey">ref - the key for the binding</param>
|
|
/// <returns>true if the binding string was understood, false if not</returns>
|
|
bool GetKeyBindingInfo( string bindString, ref BindingObject.EModifier bindModifiers, ref Keys bindKey )
|
|
{
|
|
bindString = bindString.ToUpper();
|
|
if( bindString.Length == 1 )
|
|
{
|
|
char keyChar = ( bindString.Trim().ToUpper()[ 0 ] );
|
|
int keyOffset = keyChar - 'A';
|
|
bindKey = ( Keys.A + keyOffset );
|
|
// Default To ALT Binding...
|
|
// bindModifiers = BindingObject.EModifier.Alt;
|
|
|
|
if( ( bindKey >= Keys.A ) && ( bindKey <= Keys.Z ) )
|
|
{
|
|
return( true );
|
|
}
|
|
else
|
|
{
|
|
return( false );
|
|
}
|
|
}
|
|
string[] keyTokens = bindString.Split( '+' );
|
|
bool parsed = false;
|
|
|
|
foreach( string ktoken in keyTokens )
|
|
{
|
|
if( ktoken == "ALT" )
|
|
{
|
|
bindModifiers |= BindingObject.EModifier.Alt;
|
|
continue;
|
|
}
|
|
if( ktoken == "CTRL" )
|
|
{
|
|
bindModifiers |= BindingObject.EModifier.Ctrl;
|
|
continue;
|
|
}
|
|
if( ktoken == "SHIFT" )
|
|
{
|
|
bindModifiers |= BindingObject.EModifier.Shift;
|
|
continue;
|
|
}
|
|
if( ktoken.Length == 1 )
|
|
{
|
|
int keyOffset = ktoken[ 0 ] - 'A';
|
|
bindKey = ( Keys.A + keyOffset );
|
|
if( ( bindKey >= Keys.A ) && ( bindKey <= Keys.B ) )
|
|
{
|
|
parsed = true;
|
|
}
|
|
else
|
|
{
|
|
parsed = false;
|
|
}
|
|
break;
|
|
}
|
|
else if( ( ( ktoken.Length == 2 ) || ( ktoken.Length == 3 ) ) && ( ktoken[ 0 ] == 'F' ) )
|
|
{
|
|
// F-Key Binding...
|
|
int fNumber = int.Parse( ktoken.Substring( 1 ) );
|
|
Keys fKey = ( Keys.Divide + fNumber );
|
|
|
|
if( ( fKey >= Keys.F1 ) && ( fKey <= Keys.F24 ) )
|
|
{
|
|
bindKey = fKey;
|
|
parsed = true;
|
|
}
|
|
else
|
|
{
|
|
parsed = false;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
return ( parsed );
|
|
}
|
|
/// <summary>Check for bound keys - bound keys use the <ALT> modifier</summary>
|
|
protected virtual void CheckBindings()
|
|
{
|
|
// Stop Here If No Bindings Are Set, Or No Interface To The Keyboard
|
|
if( ( ms_bindings.Count == 0 ) || ( Keyboard == null ) )
|
|
{
|
|
return;
|
|
}
|
|
//InputManager im = InputManager.Instance;
|
|
|
|
BindingObject.EModifier modifierKeys = BindingObject.EModifier.None;
|
|
bool altDown = ( ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.LeftAlt ) ) || ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.RightAlt ) ) );
|
|
bool ctrlDown = ( ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.LeftControl ) ) || ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.RightControl ) ) );
|
|
bool shiftDown = ( ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.LeftShift ) ) || ( Keyboard.CurrentKeyboardState.IsKeyDown( Keys.RightShift ) ) );
|
|
|
|
if( altDown ) modifierKeys |= BindingObject.EModifier.Alt;
|
|
if( ctrlDown ) modifierKeys |= BindingObject.EModifier.Ctrl;
|
|
if( shiftDown ) modifierKeys |= BindingObject.EModifier.Shift;
|
|
|
|
foreach( BindingObject bs in ms_bindings )
|
|
{
|
|
// See if the Binding's modifier keys are down, and its command key. If so, execute the command.
|
|
if( ( ( bs._modifierKeys & modifierKeys ) == modifierKeys ) &&
|
|
( Keyboard.NewlyPressedKeys.Contains( bs._key ) ) )
|
|
{
|
|
m_commandLine = bs._text;
|
|
ExecuteCommandLine( false );
|
|
m_commandLine = String.Empty;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>Build command matches for the specified (sub)string.</summary>
|
|
/// <param name="cmdMatch">The partial command to try to match</param>
|
|
/// <returns>Nothing</returns>
|
|
/// <remarks>Resets the ms_partialCmdMatches collection</remarks>
|
|
protected virtual void BuildCommandMatches( string cmdMatch )
|
|
{
|
|
ms_partialCmdMatches.Clear();
|
|
|
|
// Iterate Over Commands And Store Non-Secret Commands That Match Substring
|
|
foreach( CmdObject cmd in ms_commands.Values )
|
|
{
|
|
if( ( !cmd.IsSecret ) && ( cmd.Command.StartsWith( cmdMatch ) ) )
|
|
{
|
|
ms_partialCmdMatches.Add( cmd.Command );
|
|
}
|
|
}
|
|
// Iterate Over Funcitons And Store Non-Secret Functions That Match Substring
|
|
foreach( FuncObject func in ms_functions.Values )
|
|
{
|
|
if( ( !func.IsSecret ) && ( func.Function.StartsWith( cmdMatch ) ) )
|
|
{
|
|
ms_partialCmdMatches.Add( func.Function );
|
|
}
|
|
}
|
|
// Iterate Over External Funcitons And Store Non-Secret Functions That Match Substring
|
|
foreach( ExternalFuncObject extFunc in ms_externalFunctions.Values )
|
|
{
|
|
if( ( extFunc.IsSecret ) && ( extFunc.MethodName.StartsWith( cmdMatch ) ) )
|
|
{
|
|
ms_partialCmdMatches.Add( extFunc.MethodName );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Log Output
|
|
/// <summary>Add executed command output to the log.</summary>
|
|
/// <param name="text">The output text to add</param>
|
|
public void AddOutputToLog( string text )
|
|
{
|
|
if( String.IsNullOrEmpty( text ) )
|
|
{
|
|
return;
|
|
}
|
|
AddToLog( "\x03" + DateTime.Now.ToString( "hh:mm:ss.fff" ) + "-" + text );
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>Add error output to the log.</summary>
|
|
/// <param name="text">The error text to add</param>
|
|
public void AddErrorToLog( string text )
|
|
{
|
|
if( String.IsNullOrEmpty( text ) )
|
|
{
|
|
return;
|
|
}
|
|
AddToLog( "\x02" + DateTime.Now.ToString( "hh:mm:ss.fff" ) + "-" + text );
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>Add executed command to the log.</summary>
|
|
/// <param name="text">The command text to add</param>
|
|
public void AddCommandToLog( string text )
|
|
{
|
|
if( String.IsNullOrEmpty( text ) )
|
|
{
|
|
return;
|
|
}
|
|
AddToLog( "\x01" + DateTime.Now.ToString( "hh:mm:ss.fff" ) + "-" + text );
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>Method to add generic output text to the log</summary>
|
|
/// <param name="text">The text to add</param>
|
|
public void AddToLog( string text )
|
|
{
|
|
if( String.IsNullOrEmpty( text ) )
|
|
{
|
|
return;
|
|
}
|
|
if( m_logShadowEnabled )
|
|
{
|
|
m_logShadowFile.WriteLine( text );
|
|
}
|
|
lock( m_log )
|
|
{
|
|
if( ( m_screenCharWidth == 0 ) || ( text.Length < m_screenCharWidth ) )
|
|
{
|
|
m_log.Add( text );
|
|
return;
|
|
}
|
|
List<string> lines = BreakTextIntoList( text, m_consoleFont, ( m_consoleRect.Width - 10 ), Scale );
|
|
|
|
foreach( String line in lines )
|
|
{
|
|
m_log.Add( line );
|
|
}
|
|
if( m_log.Count > m_logLimit )
|
|
{
|
|
int remove = Math.Max( 32, ( m_log.Count - m_logLimit ) );
|
|
|
|
remove--;
|
|
m_log.RemoveRange( 0, remove );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// JRT Only Evaluate This Once...
|
|
private static readonly char[] DELIMITERS = " .:,/\\-+=_[]{}()?!><|".ToCharArray();
|
|
|
|
/// <summary>
|
|
/// Break text up into separate lines to make it fit.
|
|
/// (Originally From MS Provided Code - RBG Starter Kit/Template - Text Helper Methods)
|
|
/// </summary>
|
|
/// <param name="text">The text to be broken up.</param>
|
|
/// <param name="font">The font used to measure the width of the text.</param>
|
|
/// <param name="rowWidth">The maximum width of each line, in pixels.</param>
|
|
/// <param name="scale">Scale that should be used for the lines.</param>
|
|
protected static List<string> BreakTextIntoList( string text, SpriteFont font,
|
|
int rowWidth, float scale )
|
|
{
|
|
// check parameters
|
|
if( String.IsNullOrEmpty( text ) )
|
|
{
|
|
return( new List<string>( new[] { String.Empty } ) );
|
|
}
|
|
if( font == null )
|
|
{
|
|
throw new ArgumentNullException( "font" );
|
|
}
|
|
if( rowWidth <= 0 )
|
|
{
|
|
throw new ArgumentOutOfRangeException( "rowWidth" );
|
|
}
|
|
// create the list
|
|
List<string> lines = new List<string>( text.Length / rowWidth );
|
|
|
|
// check for trivial text
|
|
if( String.IsNullOrEmpty( text ) )
|
|
{
|
|
lines.Add( String.Empty );
|
|
return lines;
|
|
}
|
|
char cLead = text[ 0 ];
|
|
|
|
//
|
|
// JRT Q&D Way To Get Rid Of The Coloring Characters - They Are Not Written
|
|
// Out To The Screen, Anyway...
|
|
//
|
|
if( ( cLead == '\x01' ) || ( cLead == '\x02' ) || ( cLead == '\x03' ) )
|
|
{
|
|
text = text.Substring( 1 );
|
|
}
|
|
else
|
|
{
|
|
cLead = '\x00';
|
|
}
|
|
// check for text that fits on a single line
|
|
if( ( font.MeasureString( text ).X * scale ) <= rowWidth )
|
|
{
|
|
if( cLead != '\x00' )
|
|
{
|
|
text = text.Insert( 0, cLead.ToString() );
|
|
}
|
|
return lines;
|
|
}
|
|
|
|
StringBuilder sb = new StringBuilder( 256 );
|
|
int textIndex = 0;
|
|
int currentDelimiterIndex = 0;
|
|
|
|
// JRT This Loop Will Cause The Occasional Leading Delimiter Character If The
|
|
// Line Break Occurs At A Place Where To Delimiters Are Next To Each
|
|
// Other, But I Consider This An Acceptable Tradeoff.
|
|
//
|
|
// Lines That Cannot Be Broken-Up Will Wrap, But The Wrapping Will Not
|
|
// Be Optimal.
|
|
while( textIndex < text.Length )
|
|
{
|
|
String appendedString;
|
|
int lastLen = textIndex;
|
|
|
|
currentDelimiterIndex = text.IndexOfAny( DELIMITERS, textIndex );
|
|
if( currentDelimiterIndex == -1 )
|
|
{
|
|
appendedString = text.Substring( textIndex );
|
|
}
|
|
else
|
|
{
|
|
appendedString = text.Substring( textIndex, ( currentDelimiterIndex - textIndex + 1 ) );
|
|
}
|
|
sb.Append( appendedString );
|
|
if( ( font.MeasureString( sb.ToString() ).X * scale ) > rowWidth )
|
|
{
|
|
sb.Remove( ( sb.Length - appendedString.Length ), appendedString.Length );
|
|
if( cLead != '\x00' )
|
|
{
|
|
sb.Insert( 0, cLead );
|
|
}
|
|
lines.Add( sb.ToString() );
|
|
sb.Length = 0;
|
|
text = text.Substring( textIndex );
|
|
textIndex = 0;
|
|
}
|
|
else
|
|
{
|
|
textIndex += appendedString.Length;
|
|
}
|
|
}
|
|
if( sb.Length > 0 )
|
|
{
|
|
lines.Add( sb.ToString() );
|
|
}
|
|
return( lines );
|
|
}
|
|
#endregion
|
|
|
|
#region Built-In Commands
|
|
/// <summary>Sets up the standard/built-in commands.</summary>
|
|
protected void InitializeStandardCommands()
|
|
{
|
|
CmdObject cmdStruct = new CmdObject();
|
|
|
|
cmdStruct.Command = "help";
|
|
cmdStruct.CommandHelp = "show game console help, or help for a specific command";
|
|
cmdStruct.CommandHelpDetailed = "help [command]";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Help );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "quit";
|
|
cmdStruct.CommandHelp = "immediately quit the game";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Quit );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "close";
|
|
cmdStruct.CommandHelp = "close the command console.";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Close );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "consoleheight";
|
|
cmdStruct.MinParameters = 0;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "set the height of the console window in pixels";
|
|
cmdStruct.CommandHelpDetailed = "consoleheight <heightvalue>";
|
|
cmdStruct.CmdEvent +=new Action<string[]>(CommandConsoleBase_ConsoleHeight);
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "consolescale";
|
|
cmdStruct.MinParameters = 0;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "set the scale of the console window (1.0=100%, 0.75=75%, 0.5=50%, etc.)";
|
|
cmdStruct.CommandHelpDetailed = "consolescale<scale>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ConsoleScale );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "cvar";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 3;
|
|
cmdStruct.CommandHelp = "add a new console variable (cvar), or modify an existing one";
|
|
cmdStruct.CommandHelpDetailed = "cvar <name> [Type] <value> -- examples: cvar myVar MyValue, cvar myInt Int32 42";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_CVar );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "cvars";
|
|
cmdStruct.MinParameters = 0;
|
|
cmdStruct.MaxParameters = 0;
|
|
cmdStruct.CommandHelp = "view the available console variables (cvars)";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_CVars );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "gc";
|
|
cmdStruct.CommandHelp = "immediately perform full garbage collection";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_GC );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "shadowlog";
|
|
cmdStruct.MinParameters = 0;
|
|
cmdStruct.MaxParameters = 2;
|
|
cmdStruct.CommandHelp = "shadows the log to an external file, optionally truncating the external file first";
|
|
cmdStruct.CommandHelpDetailed = "shadowlog <filepath> <true/false>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ShadowLog );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "noshadowlog";
|
|
cmdStruct.CommandHelp = "turns off shadowing of the log to an external file";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_NoShadowLog );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "clear";
|
|
cmdStruct.CommandHelp = "clears the console log";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Clear );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "loglimit";
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "sets the console log (buffer) limit";
|
|
cmdStruct.CommandHelpDetailed = "loglimit <numlines>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_LogLimit );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "memoryinfo";
|
|
cmdStruct.CommandHelp = "display memory info";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_MemInfo );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exfunc";
|
|
cmdStruct.CommandHelp = "load external function from an assembly";
|
|
cmdStruct.CommandHelpDetailed = "exfunc <assemblypath> <classname> <functionname>";
|
|
cmdStruct.MinParameters = 3;
|
|
cmdStruct.MaxParameters = 3;
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ExFunc );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "systeminfo";
|
|
cmdStruct.CommandHelp = "display system info";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_SystemInfo );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "sleep";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "eause execution of the command console";
|
|
cmdStruct.CommandHelpDetailed = "sleep <durationms>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Sleep );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exec";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "execute contents of a file as commands in this console";
|
|
cmdStruct.CommandHelpDetailed = "exec <filepath>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Exec );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "savelog";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "save the console log to a file";
|
|
cmdStruct.CommandHelpDetailed = "savelog <filepath>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_SaveLog );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "functions";
|
|
cmdStruct.CommandHelp = "display all current functions";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Functions );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "nofunctions";
|
|
cmdStruct.CommandHelp = "disable the ability to add/remove functions";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_NoFunctions );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exfuncs";
|
|
cmdStruct.CommandHelp = "display all current external functions";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ExFuncs );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "noexfuncs";
|
|
cmdStruct.CommandHelp = "disable the ability to add/remove exfuncs";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_NoExFunctions );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "bindings";
|
|
cmdStruct.CommandHelp = "display all current key bindings";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Bindings );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "nobindings";
|
|
cmdStruct.CommandHelp = "disable the ability to add/remove bindings";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_NoBindings );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "resetbindings";
|
|
cmdStruct.CommandHelp = "clear all key bindings";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ResetBindings );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "resetexfuncs";
|
|
cmdStruct.CommandHelp = "clear all external functions";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ResetExFuncs );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "resetfunctions";
|
|
cmdStruct.CommandHelp = "clear all functions";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ResetFunctions);
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "bind";
|
|
cmdStruct.MinParameters = 2;
|
|
cmdStruct.MaxParameters = 0;
|
|
cmdStruct.CommandHelp = "bind an key to a command or function";
|
|
cmdStruct.CommandHelpDetailed = "bind <key> <commandtext/functionname> -- examples: 'bind ALT+G gc', 'bind CTRL+SHIFT+Q quit'";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Bind );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "unbind";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "remove a previous key binding";
|
|
cmdStruct.CommandHelpDetailed = "unbind <key>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_UnBind );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "function";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 0;
|
|
cmdStruct.CommandHelp = "create a new function";
|
|
cmdStruct.CommandHelpDetailed = "function <functionname> <line>;<line>;<...>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_Function );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exportfunctions";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "export functions to a file that can be EXEC-ed";
|
|
cmdStruct.CommandHelpDetailed = "exportfunctions <filepath>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ExportFunctions );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exportexfuncs";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "export exfuncs to a file that can be EXEC-ed";
|
|
cmdStruct.CommandHelpDetailed = "exportexfuncs <filepath>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ExportExFuncs );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exportbindings";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "export binding information to a file that can be EXEC-ed";
|
|
cmdStruct.CommandHelpDetailed = "exportbindings <filepath>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ExportBindings );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
cmdStruct = new CmdObject();
|
|
cmdStruct.Command = "exportstate";
|
|
cmdStruct.MinParameters = 1;
|
|
cmdStruct.MaxParameters = 1;
|
|
cmdStruct.CommandHelp = "export the console's complete state information to a file that can be EXEC-ed, so that the state can be restored later";
|
|
cmdStruct.CommandHelpDetailed = "exportstate <filepath>";
|
|
cmdStruct.CmdEvent += new Action<string[]>( CommandConsoleBase_ExportState );
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overridable method used to add custom commands to the console.
|
|
/// </summary>
|
|
public virtual void InitializeCustomCommands()
|
|
{
|
|
return;
|
|
}
|
|
|
|
/// <summary>Initialize the Console's Commands -- is normally called via <see cref="LoadContent"/></summary>
|
|
public void InitializeCommands()
|
|
{
|
|
InitializeStandardCommands();
|
|
|
|
InitializeCustomCommands();
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a command to the internal collection of commands. Throws an exception if duplicate identifiers are detected.
|
|
/// </summary>
|
|
/// <param name="cmdStruct">Command object to add</param>
|
|
protected void AddCommand( CmdObject cmdStruct )
|
|
{
|
|
cmdStruct.Command = cmdStruct.Command.Trim().ToLowerInvariant();
|
|
|
|
if( ms_commands.ContainsKey( cmdStruct.Command ) )
|
|
{
|
|
throw( new InvalidOperationException( String.Format(
|
|
"Command {0} already exists in the command list.",
|
|
cmdStruct.Command ) ) );
|
|
}
|
|
if( ms_functions.ContainsKey( cmdStruct.Command ) )
|
|
{
|
|
throw ( new InvalidOperationException( String.Format(
|
|
"Command {0} already exists as a function.",
|
|
cmdStruct.Command ) ) );
|
|
}
|
|
ms_commands[ cmdStruct.Command ] = cmdStruct;
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a function to the internal collection of functions. Throws an exception if duplicate identifiers are detected.
|
|
/// </summary>
|
|
/// <param name="fnStruct">Function object to add</param>
|
|
protected void AddFunction( FuncObject fnStruct )
|
|
{
|
|
if( ms_commands.ContainsKey( fnStruct.Function ) )
|
|
{
|
|
throw ( new InvalidOperationException( String.Format(
|
|
"Function {0} already exists as a command.",
|
|
fnStruct.Function ) ) );
|
|
}
|
|
if( ms_functions.ContainsKey( fnStruct.Function ) )
|
|
{
|
|
throw ( new InvalidOperationException( String.Format(
|
|
"Function {0} already exists in the function list.",
|
|
fnStruct.Function ) ) );
|
|
}
|
|
ms_functions[ fnStruct.Function ] = fnStruct;
|
|
|
|
return;
|
|
}
|
|
#endregion
|
|
|
|
#region Command Processing
|
|
/// <summary>Execute the specified Function</summary>
|
|
/// <param name="fnStruct">Function to execute</param>
|
|
/// <param name="parameters">Parameters for the function</param>
|
|
protected void ExecuteFunction( FuncObject fnStruct, string[] parameters )
|
|
{
|
|
foreach( string line in fnStruct.FunctionImpl )
|
|
{
|
|
m_commandLine = line;
|
|
// If Function Parameters Exist, And Function Takes Parameters
|
|
if( ( parameters != null ) && ( m_commandLine.IndexOf( '%' ) != -1 ) )
|
|
{
|
|
int count = 0;
|
|
|
|
// Build The Resulting Command Line
|
|
foreach( string param in parameters )
|
|
{
|
|
m_commandLine = m_commandLine.Replace( "%" + count, parameters[ count ] );
|
|
count++;
|
|
}
|
|
}
|
|
AddToLog( "\x01-> " + m_commandLine );
|
|
ExecuteCommandLine( false );
|
|
m_commandLine = String.Empty;
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>Evaluates and executes the command line stored in the "_command" field.</summary>
|
|
public virtual void ExecuteCommandLine( bool addToHistory )
|
|
{
|
|
string trimmedCmdLine = m_commandLine.Trim();
|
|
|
|
// Ignore Empty And Whitespace Command Lines...
|
|
if( String.IsNullOrWhiteSpace( trimmedCmdLine ) )
|
|
{
|
|
return;
|
|
}
|
|
// Ignore Comments...
|
|
if( trimmedCmdLine[ 0 ] == '#' )
|
|
{
|
|
return;
|
|
}
|
|
// Bang Indicates That This Line Should NOT Be Added To Command History
|
|
if (trimmedCmdLine[0] == '!')
|
|
{
|
|
addToHistory = false;
|
|
trimmedCmdLine = trimmedCmdLine.Substring(1);
|
|
}
|
|
else if( addToHistory )
|
|
{
|
|
m_cmdHistory.Add(trimmedCmdLine);
|
|
if( m_cmdHistory.Count > m_cmdHistoryLimit )
|
|
{
|
|
m_cmdHistory.RemoveAt(m_cmdHistoryLimit);
|
|
}
|
|
m_cmdHistoryIndex = m_cmdHistory.Count;
|
|
// m_cmdHistoryIndex = ( m_cmdHistory.Count - 1 );
|
|
m_cmdHistoryScanIndex = m_cmdHistoryIndex;
|
|
}
|
|
// If A PreCommand Execution Handling Delegate Has Been Set,
|
|
// Execute The Delegate And See If The Command Was Handled
|
|
// Externally.
|
|
if( PreCommandExecutedEvent != null )
|
|
{
|
|
CommandConsoleEventArgs ea = new CommandConsoleEventArgs( trimmedCmdLine );
|
|
|
|
try
|
|
{
|
|
PreCommandExecutedEvent( this, ea );
|
|
trimmedCmdLine = ea.CmdLine;
|
|
}
|
|
catch( Exception ex )
|
|
{
|
|
AddErrorToLog( "** PreCommandExecuted delegate(s) thrown an exception: " + ex.Message );
|
|
}
|
|
if( ea.Handled )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
try
|
|
{
|
|
CmdObject cs;
|
|
String[] cmds = trimmedCmdLine.Split( ' ' );
|
|
String cmd = cmds[ 0 ].ToLowerInvariant();
|
|
bool found = false;
|
|
|
|
// Commands Are more Common Then Functions, So Check them First.
|
|
if( ms_commands.TryGetValue( cmd, out cs ) )
|
|
{
|
|
found = ExecuteCommand( cs, cmds, cmd );
|
|
}
|
|
// Next, Try External Functions...
|
|
if( ( !found ) && ( ms_externalFunctions.Count > 0 ) )
|
|
{
|
|
found = ExecuteExternalFunc( cmds, cmd );
|
|
}
|
|
// Next, Try Internal Functions...
|
|
if( ( !found ) && ( ms_functions.Count > 0 ) )
|
|
{
|
|
found = ExecuteInternalFunc( cmds, cmd );
|
|
}
|
|
// Lastly, See If A Console Variable...
|
|
if( ( !found ) && ( m_cVars.Count > 0 ) )
|
|
{
|
|
found = HandleCVar( cmds, cmd );
|
|
}
|
|
// If STILL Not Found...
|
|
if( !found )
|
|
{
|
|
AddErrorToLog( "** Unknown command: " + trimmedCmdLine );
|
|
AddErrorToLog( "** type help for commands and usage." );
|
|
}
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
AddErrorToLog( String.Format( "Exception while processing \"{0}\" : {1}", trimmedCmdLine, e.Message ) );
|
|
}
|
|
return;
|
|
}
|
|
|
|
/// <summary>Handle set/get cvar</summary>
|
|
/// <param name="cmds">Command Line</param>
|
|
/// <param name="cmd">Pre-processed command</param>
|
|
/// <returns>true if command was handled by this function</returns>
|
|
private bool HandleCVar( String[] cmds, String cmd )
|
|
{
|
|
CVar cvar;
|
|
bool found = false;
|
|
|
|
lock( m_cVars )
|
|
{
|
|
if( m_cVars.TryGetValue( cmd, out cvar ) )
|
|
{
|
|
found = true;
|
|
if( cmds.Length == 1 )
|
|
{
|
|
AddOutputToLog( String.Format( "{0} ({1}) = {2}",
|
|
cvar.Name, cvar.ValueType.ToString(), cvar.Value.ToString() ) );
|
|
}
|
|
else
|
|
{
|
|
cvar.Value = GetObjFromString( cvar.ValueType, cmds[ 1 ] );
|
|
if( CVarModifiedEvent != null )
|
|
{
|
|
CVarModifiedEvent.Invoke( this, new CVarModifiedEventArgs( cvar ) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return( found );
|
|
}
|
|
|
|
/// <summary>Execute an internal function</summary>
|
|
/// <param name="cmds">Command Line</param>
|
|
/// <param name="cmd">Pre-processed command</param>
|
|
/// <returns>true if command was handled by this function</returns>
|
|
private bool ExecuteInternalFunc( String[] cmds, String cmd )
|
|
{
|
|
FuncObject fs;
|
|
bool found = false;
|
|
|
|
if( ms_functions.TryGetValue( cmd, out fs ) )
|
|
{
|
|
string[] parameters = new string[ cmds.Length - 1 ];
|
|
for( int param = 1; param < cmds.Length; param++ )
|
|
{
|
|
parameters[ param - 1 ] = cmds[ param ];
|
|
}
|
|
ExecuteFunction( fs, parameters );
|
|
found = true;
|
|
}
|
|
return( found );
|
|
}
|
|
|
|
/// <summary>Execute a previously loaded external function</summary>
|
|
/// <param name="cmds">Command Line</param>
|
|
/// <param name="cmd">Pre-processed command</param>
|
|
/// <returns>true if command was handled by this function</returns>
|
|
private bool ExecuteExternalFunc( String[] cmds, String cmd )
|
|
{
|
|
ExternalFuncObject efs;
|
|
bool found = false;
|
|
|
|
// If Not Found, Try To Match Against External Functions
|
|
if( ms_externalFunctions.TryGetValue( cmd, out efs ) )
|
|
{
|
|
string[] parameters = new string[ cmds.Length - 1 ];
|
|
List<object> cVarParams = new List<object>( 2 );
|
|
bool doInvoke = true;
|
|
|
|
for( int param = 1; param < cmds.Length; param++ )
|
|
{
|
|
try
|
|
{
|
|
cVarParams.Add( m_cVars[ cmds[ param ].ToLowerInvariant() ] );
|
|
}
|
|
catch( Exception ex )
|
|
{
|
|
doInvoke = false;
|
|
AddErrorToLog( "Exception while building parameters for external function: " + ex.Message );
|
|
}
|
|
}
|
|
if( doInvoke )
|
|
{
|
|
string ret = efs.Invoke( cVarParams.ToArray() );
|
|
|
|
if( CVarModifiedEvent != null )
|
|
{
|
|
foreach( CVar invokedVar in cVarParams )
|
|
{
|
|
CVarModifiedEvent.Invoke( this,
|
|
new CVarModifiedEventArgs( invokedVar ) );
|
|
}
|
|
}
|
|
if( String.IsNullOrWhiteSpace( ret ) == false )
|
|
{
|
|
AddOutputToLog( ret );
|
|
}
|
|
}
|
|
found = true;
|
|
}
|
|
return found;
|
|
}
|
|
|
|
/// <summary>Execute a normal command</summary>
|
|
/// <param name="cs">Command Object</param>
|
|
/// <param name="cmds">Command Line</param>
|
|
/// <param name="cmd">Pre-processed command</param>
|
|
/// <returns>true if command was handled by this function</returns>
|
|
private bool ExecuteCommand( CmdObject cs, String[] cmds, String cmd )
|
|
{
|
|
int parameters = ( cmds.Length - 1 );
|
|
|
|
// Validate the parameter counts
|
|
if( ( cs.MinParameters != 0 ) && ( parameters < cs.MinParameters ) )
|
|
{
|
|
AddErrorToLog( "Not enough parameters specified for the " + cmd + " command." );
|
|
if( !String.IsNullOrEmpty( cs.CommandHelpDetailed ) )
|
|
{
|
|
AddToLog( cs.CommandHelpDetailed );
|
|
}
|
|
}
|
|
else if( ( cs.MaxParameters != 0 ) && ( parameters > cs.MaxParameters ) )
|
|
{
|
|
AddErrorToLog( "Too many parameters specified for the " + cmd + " command." );
|
|
if( !String.IsNullOrEmpty( cs.CommandHelpDetailed ) )
|
|
{
|
|
AddToLog( cs.CommandHelpDetailed );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fire The Delegate!
|
|
cs.TriggerEvent( cmds );
|
|
}
|
|
return( true );
|
|
}
|
|
#endregion
|
|
|
|
#region Parsing Helpers
|
|
/// <summary>Try to extract a double/Double value from the string</summary>
|
|
/// <param name="value">Value to parse</param>
|
|
/// <param name="parsedValue">out - receives the value parsed from the string</param>
|
|
/// <param name="errorIfParsingFails">Error msg to log if parsing fails</param>
|
|
/// <returns>True if parsed successfully, false otherwise</returns>
|
|
protected bool TryParseDouble( string value, out double parsedValue, string errorIfParsingFails )
|
|
{
|
|
if( !Double.TryParse( value, out parsedValue ) )
|
|
{
|
|
AddErrorToLog( errorIfParsingFails );
|
|
return ( false );
|
|
}
|
|
return ( true );
|
|
}
|
|
/// <summary>Try to extract a float/Single value from the string</summary>
|
|
/// <param name="value">Value to parse</param>
|
|
/// <param name="parsedValue">out - receives the value parsed from the string</param>
|
|
/// <param name="errorIfParsingFails">Error msg to log if parsing fails</param>
|
|
/// <returns>True if parsed successfully, false otherwise</returns>
|
|
protected bool TryParseFloat( string value, out float parsedValue, string errorIfParsingFails )
|
|
{
|
|
if( !Single.TryParse( value, out parsedValue ) )
|
|
{
|
|
AddErrorToLog( errorIfParsingFails );
|
|
return ( false );
|
|
}
|
|
return ( true );
|
|
}
|
|
/// <summary>Try to extract an int/Int32 value from the string</summary>
|
|
/// <param name="value">Value to parse</param>
|
|
/// <param name="parsedValue">out - receives the value parsed from the string</param>
|
|
/// <param name="errorIfParsingFails">Error msg to log if parsing fails</param>
|
|
/// <returns>True if parsed successfully, false otherwise</returns>
|
|
protected bool TryParseInt( string value, out int parsedValue, string errorIfParsingFails )
|
|
{
|
|
if( !Int32.TryParse( value, out parsedValue ) )
|
|
{
|
|
AddErrorToLog( errorIfParsingFails );
|
|
return ( false );
|
|
}
|
|
return ( true );
|
|
}
|
|
#endregion
|
|
#region Standard Command Handlers
|
|
void CommandConsoleBase_Help( string[] cmdLine )
|
|
{
|
|
if( cmdLine.Length == 1 )
|
|
{
|
|
StringBuilder sb = new StringBuilder( 512 );
|
|
bool first = true;
|
|
|
|
sb.Append( "Commands: " );
|
|
foreach( CmdObject cs in ms_commands.Values )
|
|
{
|
|
if( ( String.IsNullOrEmpty( cs.Command ) ) ||
|
|
( cs.IsSecret ) )
|
|
{
|
|
continue;
|
|
}
|
|
if( !first )
|
|
{
|
|
sb.Append( ", " );
|
|
}
|
|
first = false;
|
|
sb.Append( cs.Command );
|
|
}
|
|
AddToLog( sb.ToString() );
|
|
}
|
|
else if( cmdLine.Length == 2 )
|
|
{
|
|
CmdObject cs;
|
|
String helpCommand = cmdLine[ 1 ];
|
|
bool found = false;
|
|
|
|
if( ms_commands.TryGetValue( helpCommand, out cs ) )
|
|
{
|
|
AddToLog( cs.Command + " - " + cs.CommandHelp );
|
|
if( !String.IsNullOrEmpty( cs.CommandHelpDetailed ) )
|
|
{
|
|
AddToLog( cs.CommandHelpDetailed );
|
|
}
|
|
found = true;
|
|
}
|
|
if( !found )
|
|
{
|
|
AddErrorToLog( "Unknown command: " + helpCommand );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AddErrorToLog( "Too many parameters specified. Try help or help <command>." );
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_Quit( string[] cmdLine )
|
|
{
|
|
// Stop -- no questions asked!
|
|
Game.Exit();
|
|
|
|
return;
|
|
}
|
|
void CommandConsoleBase_Exec( string[] cmdLine )
|
|
{
|
|
string scriptFile = cmdLine[ 1 ];
|
|
|
|
if( !File.Exists( scriptFile ) )
|
|
{
|
|
AddErrorToLog( "Unable to execute " + scriptFile + ", the file cannot be found." );
|
|
return;
|
|
}
|
|
string[] commandLines = File.ReadAllLines( cmdLine[ 1 ] );
|
|
|
|
if( commandLines.Length == 0 )
|
|
{
|
|
AddErrorToLog( "File: " + scriptFile + " contains no lines." );
|
|
return;
|
|
}
|
|
AddOutputToLog( "<--- Starting execution of commands from: " + scriptFile + " at " + DateTime.Now.ToString( "hh:mm:ss.fff" ) );
|
|
|
|
bool bAddToHistory = commandLines[ 0 ].StartsWith( "!!" );
|
|
|
|
foreach( string cmd in commandLines )
|
|
{
|
|
string cmdFixed = cmd.Trim();
|
|
|
|
AddToLog( "\x01-> " + cmd );
|
|
if( cmdFixed.Length == 0 )
|
|
{
|
|
continue;
|
|
}
|
|
m_logStart = 0;
|
|
m_commandLine = cmdFixed;
|
|
ExecuteCommandLine( bAddToHistory );
|
|
m_commandLine = String.Empty;
|
|
}
|
|
AddOutputToLog( "<--- Ended execution of commands from: " + scriptFile + " at " + DateTime.Now.ToString( "hh:mm:ss.fff" ) );
|
|
|
|
return;
|
|
}
|
|
void CommandConsoleBase_SaveLog( string[] cmdLine )
|
|
{
|
|
string[] lines = new String[ m_log.Count ];
|
|
|
|
m_log.CopyTo( lines );
|
|
File.WriteAllLines( cmdLine[ 1 ], lines );
|
|
AddOutputToLog( "<--- Log has been written to: " + cmdLine[ 1 ] );
|
|
|
|
return;
|
|
}
|
|
void CommandConsoleBase_GC( string[] cmdLine )
|
|
{
|
|
AddOutputToLog( "Forcing Garbage Collection..." );
|
|
DateTime now = DateTime.Now;
|
|
|
|
GC.Collect( 3, GCCollectionMode.Forced );
|
|
GC.Collect( 2, GCCollectionMode.Forced );
|
|
GC.Collect( 1, GCCollectionMode.Forced );
|
|
|
|
TimeSpan delta = DateTime.Now.Subtract( now );
|
|
AddOutputToLog( "Garbage Collection took ~" + delta.TotalMilliseconds + "ms" );
|
|
|
|
return;
|
|
}
|
|
void CommandConsoleBase_MemInfo( string[] cmdLine )
|
|
{
|
|
AddOutputToLog( "WSMem: " + Environment.WorkingSet );
|
|
AddOutputToLog( "GCC1 : " + GC.CollectionCount( 0 ) );
|
|
AddOutputToLog( "GCC2 : " + GC.CollectionCount( 1 ) );
|
|
AddOutputToLog( "GCC3 : " + GC.CollectionCount( 2 ) );
|
|
AddOutputToLog( "Total: " + GC.GetTotalMemory( false ) );
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ExFunc( string[] cmdLine )
|
|
{
|
|
if( m_exfunsLocked )
|
|
{
|
|
AddErrorToLog( "ExFunc-related actions have been disabled." );
|
|
return;
|
|
}
|
|
string assembly = cmdLine[ 1 ];
|
|
string className = cmdLine[ 2 ];
|
|
string funcName = cmdLine[ 3 ];
|
|
bool isSecret = false;
|
|
|
|
isSecret = ( ( cmdLine.Length == 5 ) &&
|
|
( cmdLine[ 4 ].ToLowerInvariant() == "secret" ) );
|
|
try
|
|
{
|
|
ExternalFuncObject efo = new ExternalFuncObject( assembly, className, funcName );
|
|
|
|
efo.CommandLine = String.Format(
|
|
"exfunc {0} {1} {2}{3}",
|
|
assembly, className, funcName,
|
|
isSecret ? "secret" : String.Empty );
|
|
ms_externalFunctions.Add( funcName.ToLowerInvariant(), efo );
|
|
AddOutputToLog( String.Format(
|
|
"Added external function {0}::{1}::{2}",
|
|
assembly, className, funcName ) );
|
|
}
|
|
catch( Exception ex )
|
|
{
|
|
AddErrorToLog( String.Format(
|
|
"Unable to load/add {0}::{1}::{2} = {3}",
|
|
assembly, className, funcName, ex.Message ) );
|
|
}
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_SystemInfo( string[] cmdLine )
|
|
{
|
|
AddOutputToLog( "Name : " + Environment.MachineName );
|
|
AddOutputToLog( "OSVer : " + Environment.OSVersion );
|
|
AddOutputToLog( "64BitOS : " + Environment.Is64BitOperatingSystem );
|
|
AddOutputToLog( "64BitProcess : " + Environment.Is64BitProcess );
|
|
AddOutputToLog( "PageFile : " + Environment.SystemPageSize );
|
|
AddOutputToLog( "CPUs : " + Environment.ProcessorCount );
|
|
AddOutputToLog( "CLRVer : " + Environment.Version );
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>Type converter helper - tries to convert the specified string to the specified type</summary>
|
|
/// <param name="type">The target type to convert to</param>
|
|
/// <param name="mystring">The source string to try to convert</param>
|
|
/// <returns>A reference to the successfully converted object, or null if conversion failed</returns>
|
|
public static object GetObjFromString( Type type, string mystring )
|
|
{
|
|
var foo = TypeDescriptor.GetConverter( type );
|
|
|
|
// Try To Convert From String To The Target Type Using Both Culture-Sensitive
|
|
// And The Culture-Insensitive Conversion. If Both Fail, Default To String
|
|
// Type.
|
|
try
|
|
{
|
|
return ( foo.ConvertFromString( mystring ) );
|
|
}
|
|
catch( Exception )
|
|
{
|
|
try
|
|
{
|
|
return ( foo.ConvertFromInvariantString( mystring ) );
|
|
}
|
|
catch( Exception )
|
|
{
|
|
// Just Eat This One
|
|
}
|
|
}
|
|
// If Conversion Fails, Fall Back To String Type
|
|
return ( mystring );
|
|
}
|
|
|
|
void CommandConsoleBase_CVar( string[] cmdLine )
|
|
{
|
|
CVar cvar = null;
|
|
|
|
lock( m_cVars )
|
|
{
|
|
string cvarName = cmdLine[ 1 ].ToLowerInvariant();
|
|
|
|
// Isn't this preventing us from modifying a cvar?
|
|
// -- Nathan Adams [adamsna@datanethost.net] - 6/3/2012
|
|
if( m_cVars.TryGetValue( cvarName, out cvar ) )
|
|
{
|
|
AddErrorToLog( "CVar " + cmdLine[ 1 ] +
|
|
" already exists with a value of: " + cvar.Value ?? "(null" );
|
|
return;
|
|
}
|
|
|
|
if( cmdLine.Length == 4 )
|
|
{
|
|
string typeName = cmdLine[ 2 ];
|
|
Type cvarType = Type.GetType( typeName, false );
|
|
|
|
if( cvarType == null )
|
|
{
|
|
cvarType = Type.GetType( "System." + typeName, false );
|
|
}
|
|
if( cvarType == null )
|
|
{
|
|
AddErrorToLog( "Cannot resolve type " + typeName +
|
|
" -- try a fully qualified type name" );
|
|
return;
|
|
}
|
|
object objValue = GetObjFromString( cvarType, cmdLine[ 3 ] );
|
|
|
|
cvar = new CVar( cvarName, objValue );
|
|
}
|
|
else if( cmdLine.Length == 3 )
|
|
{
|
|
cvar = new CVar( cvarName, cmdLine[ 2 ] );
|
|
}
|
|
else
|
|
{
|
|
cvar = new CVar( cvarName );
|
|
}
|
|
m_cVars[ cvarName ] = cvar;
|
|
|
|
AddOutputToLog( "CVar " + cvarName + " has been added" );
|
|
}
|
|
if( ( cvar != null ) && ( CVarModifiedEvent != null ) )
|
|
{
|
|
CVarModifiedEvent.Invoke(this, new CVarModifiedEventArgs(cvar));
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_CVars( string[] cmdLine )
|
|
{
|
|
AddOutputToLog( "cvars:" );
|
|
lock( m_cVars )
|
|
{
|
|
foreach( CVar cvar in m_cVars.Values )
|
|
{
|
|
if( cvar.Value != null )
|
|
{
|
|
AddOutputToLog( String.Format( "{0} ({1}) = {2}",
|
|
cvar.Name, cvar.ValueType.ToString(), cvar.Value.ToString() ) );
|
|
}
|
|
else
|
|
{
|
|
AddOutputToLog( cvar.Name + " (null) = null" );
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_ConsoleScale( string[] cmdLine )
|
|
{
|
|
if( cmdLine.Length < 2 )
|
|
{
|
|
AddOutputToLog( "Current ConsoleScale is: " + Scale );
|
|
return;
|
|
}
|
|
float newScale;
|
|
|
|
if( !TryParseFloat( cmdLine[ 1 ], out newScale,
|
|
"Invalid scale - the specified value cannot be parsed" ) )
|
|
{
|
|
return;
|
|
}
|
|
if( ( newScale < 0.10f ) || ( newScale > 4.0f ) )
|
|
{
|
|
AddErrorToLog( "Invalid scale - must be between 0.10 (10%) and 4.0 (400%)" );
|
|
}
|
|
else
|
|
{
|
|
Scale = newScale;
|
|
m_stringHeight = Vector2.Zero;
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_ConsoleHeight( string[] cmdLine )
|
|
{
|
|
if( cmdLine.Length < 2 )
|
|
{
|
|
AddOutputToLog( "Current ConsoleHeight value is: " + m_height );
|
|
return;
|
|
}
|
|
int newHeight;
|
|
|
|
if( !TryParseInt( cmdLine[ 1 ], out newHeight,
|
|
"Invalid height - the specified value cannot be parsed" ) )
|
|
{
|
|
return;
|
|
}
|
|
if( ( newHeight < 100 ) || ( newHeight > ( GraphicsDevice.Viewport.Height - 100 ) ) )
|
|
{
|
|
AddErrorToLog( "Invalid height - must be between 100 and " + ( GraphicsDevice.Viewport.Height - 100 ) );
|
|
}
|
|
else
|
|
{
|
|
m_height = newHeight;
|
|
m_stringHeight = Vector2.Zero;
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_Sleep( string[] cmdLine )
|
|
{
|
|
int sleepms;
|
|
|
|
if( !TryParseInt( cmdLine[ 1 ], out sleepms,
|
|
"Invalid sleep duration - the specified value cannot be parsed" ) )
|
|
{
|
|
return;
|
|
}
|
|
Thread.Sleep( sleepms );
|
|
|
|
return;
|
|
}
|
|
void CommandConsoleBase_LogLimit( string[] cmdLine )
|
|
{
|
|
if( cmdLine.Length < 2 )
|
|
{
|
|
AddOutputToLog( "Current LogLimit value is: " + m_logLimit );
|
|
return;
|
|
}
|
|
int lines;
|
|
|
|
if( !TryParseInt( cmdLine[ 1 ], out lines,
|
|
"Invalid line count - the specified value cannot be parsed" ) )
|
|
{
|
|
return;
|
|
}
|
|
if( ( lines < 32 ) || ( lines > 10240 ) )
|
|
{
|
|
AddErrorToLog( "Invalid line count - must be between 32 and 10240" );
|
|
}
|
|
else
|
|
{
|
|
m_logLimit = lines;
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_Close( string[] cmdLine )
|
|
{
|
|
Active = false;
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ShadowLog( string[] cmdLine )
|
|
{
|
|
if( cmdLine.Length == 1 )
|
|
{
|
|
if( m_logShadowEnabled )
|
|
{
|
|
AddOutputToLog( "Log shadowing is enabled, writing to: " + m_logShadowFilePath );
|
|
m_logShadowFile.Flush();
|
|
}
|
|
else
|
|
{
|
|
AddOutputToLog( "Log shadowing is disabled." );
|
|
}
|
|
return;
|
|
}
|
|
string filePath = cmdLine[ 1 ];
|
|
bool truncate = false;
|
|
|
|
if( cmdLine.Length == 3 )
|
|
{
|
|
if( ( bool.TryParse( cmdLine[ 2 ], out truncate ) ) && ( truncate ) )
|
|
{
|
|
File.Delete( cmdLine[ 2 ] );
|
|
}
|
|
}
|
|
m_logShadowFile = new StreamWriter( filePath, !truncate, Encoding.ASCII );
|
|
m_logShadowFilePath = filePath;
|
|
m_logShadowEnabled = true;
|
|
|
|
AddOutputToLog( "Log shadowing has been enabled." );
|
|
|
|
return;
|
|
}
|
|
void CommandConsoleBase_NoShadowLog( string[] cmdLine )
|
|
{
|
|
if( m_logShadowEnabled )
|
|
{
|
|
m_logShadowFile.Close();
|
|
m_logShadowFile = null;
|
|
m_logShadowEnabled = false;
|
|
AddOutputToLog( "Log shadowing has been disabled." );
|
|
}
|
|
else
|
|
{
|
|
AddOutputToLog( "Log shadowing was not enabled." );
|
|
}
|
|
return;
|
|
}
|
|
void CommandConsoleBase_Clear( string[] cmdLine )
|
|
{
|
|
m_log.Clear();
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_NoFunctions( string[] cmdLine )
|
|
{
|
|
m_functionsLocked = true;
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_NoBindings( string[] cmdLine )
|
|
{
|
|
m_bindingsLocked = true;
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_NoExFunctions( string[] cmdLine )
|
|
{
|
|
m_exfunsLocked = true;
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_Bindings( string[] cmdLine )
|
|
{
|
|
if( ms_bindings.Count == 0 )
|
|
{
|
|
AddOutputToLog( "No bindings have been set." );
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder( 255 );
|
|
bool first = true;
|
|
|
|
sb.Append( "Bindings: " );
|
|
foreach( BindingObject bs in ms_bindings )
|
|
{
|
|
if( !first )
|
|
{
|
|
sb.Append( ", " );
|
|
}
|
|
first = false;
|
|
sb.Append( bs.ToString() );
|
|
}
|
|
AddToLog( sb.ToString() );
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ResetBindings( string[] cmdLine )
|
|
{
|
|
if( m_bindingsLocked )
|
|
{
|
|
AddErrorToLog( "Binding-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_bindings.Count == 0 )
|
|
{
|
|
AddOutputToLog( "No bindings have been set." );
|
|
return;
|
|
}
|
|
ms_bindings.Clear();
|
|
|
|
AddOutputToLog( "All bindings have been cleared." );
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ResetFunctions( string[] cmdLine )
|
|
{
|
|
if( m_functionsLocked )
|
|
{
|
|
AddErrorToLog( "Function-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_functions.Count == 0 )
|
|
{
|
|
AddOutputToLog( "No functions have been created." );
|
|
return;
|
|
}
|
|
ms_functions.Clear();
|
|
|
|
AddOutputToLog( "All functions have been cleared." );
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ResetExFuncs( string[] cmdLine )
|
|
{
|
|
if( m_exfunsLocked )
|
|
{
|
|
AddErrorToLog( "ExFunc-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_externalFunctions.Count == 0 )
|
|
{
|
|
AddOutputToLog( "No external functions have been added." );
|
|
return;
|
|
}
|
|
ms_externalFunctions.Clear();
|
|
|
|
AddOutputToLog( "All external functions have been cleared." );
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ExFuncs( string[] cmdLine )
|
|
{
|
|
if( m_exfunsLocked )
|
|
{
|
|
AddErrorToLog( "ExFunc-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_externalFunctions.Count == 0 )
|
|
{
|
|
AddOutputToLog( "No external functions have been added." );
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder( 255 );
|
|
bool first = true;
|
|
|
|
sb.Append( "ExFuncs: " );
|
|
foreach( ExternalFuncObject ef in ms_externalFunctions.Values )
|
|
{
|
|
if( !first )
|
|
{
|
|
sb.Append( ", " );
|
|
}
|
|
first = false;
|
|
sb.Append( ef.ToString() );
|
|
}
|
|
AddToLog( sb.ToString() );
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_Functions( string[] cmdLine )
|
|
{
|
|
if( ms_functions.Count == 0 )
|
|
{
|
|
AddOutputToLog( "No functions have been created." );
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder( 255 );
|
|
bool first = true;
|
|
|
|
sb.Append( "Functions: " );
|
|
foreach( FuncObject fs in ms_functions.Values )
|
|
{
|
|
if( !first )
|
|
{
|
|
sb.Append( ", " );
|
|
}
|
|
first = false;
|
|
sb.Append( fs.ToString() );
|
|
}
|
|
AddToLog( sb.ToString() );
|
|
return;
|
|
}
|
|
|
|
private List<string> GetAllExFuncs()
|
|
{
|
|
List<string> exFuncs = new List<string>( ms_externalFunctions.Count );
|
|
|
|
foreach( ExternalFuncObject efo in ms_externalFunctions.Values )
|
|
{
|
|
exFuncs.Add( efo.CommandLine );
|
|
}
|
|
return( exFuncs );
|
|
}
|
|
|
|
private List<string> GetAllFunctions()
|
|
{
|
|
List<string> functions = new List<string>( ms_functions.Count );
|
|
|
|
foreach( FuncObject fs in ms_functions.Values )
|
|
{
|
|
string fnText = "function " +
|
|
fs.ToString().Replace( "-> ", String.Empty );
|
|
|
|
//foreach( string fnline in fs.FunctionImpl )
|
|
//{
|
|
// fnText += fnline;
|
|
// fnText += ";";
|
|
//}
|
|
//functions.Add( "function " + fs.Function + " " + fnText );
|
|
functions.Add( fnText );
|
|
}
|
|
return( functions );
|
|
}
|
|
|
|
private List< string > GetAllBindings()
|
|
{
|
|
List<string> bindings = new List<string>( ms_bindings.Count );
|
|
|
|
foreach( BindingObject bo in ms_bindings )
|
|
{
|
|
bindings.Add( "bind " + bo.GetModifierString() + bo._key + " " + bo._text );
|
|
}
|
|
return( bindings );
|
|
}
|
|
|
|
void CommandConsoleBase_ExportBindings( string[] cmdLine )
|
|
{
|
|
if( m_bindingsLocked )
|
|
{
|
|
AddErrorToLog( "Binding-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_bindings.Count == 0 )
|
|
{
|
|
AddErrorToLog( "No bindings have been set." );
|
|
return;
|
|
}
|
|
string filePath = cmdLine[ 1 ];
|
|
|
|
File.WriteAllLines( filePath, GetAllBindings().ToArray() );
|
|
|
|
AddOutputToLog( "Bindings have been saved to: " + filePath );
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ExportFunctions( string[] cmdLine )
|
|
{
|
|
if( m_functionsLocked )
|
|
{
|
|
AddErrorToLog( "Function-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_functions.Count == 0 )
|
|
{
|
|
AddErrorToLog( "No functions have been set." );
|
|
return;
|
|
}
|
|
string filePath = cmdLine[ 1 ];
|
|
|
|
File.WriteAllLines( filePath, GetAllFunctions().ToArray() );
|
|
AddOutputToLog( "Functions have been saved to: " + filePath );
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_ExportExFuncs( string[] cmdLine )
|
|
{
|
|
if( m_exfunsLocked )
|
|
{
|
|
AddErrorToLog( "ExFunc-related actions have been disabled." );
|
|
return;
|
|
}
|
|
if( ms_externalFunctions.Count == 0 )
|
|
{
|
|
AddErrorToLog( "No ExFuncs have been set." );
|
|
return;
|
|
}
|
|
string filePath = cmdLine[ 1 ];
|
|
|
|
File.WriteAllLines( filePath, GetAllExFuncs().ToArray() );
|
|
AddOutputToLog( "ExFunc defs have been saved to: " + filePath );
|
|
|
|
return;
|
|
}
|
|
|
|
/// <summary>Special command handler for ExportState command</summary>
|
|
/// <param name="cmdLine">The command line for the command</param>
|
|
/// <remarks>This one is protected virtual so additional state can be stored if necessary by derived classes</remarks>
|
|
protected virtual void CommandConsoleBase_ExportState( string[] cmdLine )
|
|
{
|
|
string filePath = cmdLine[ 1 ];
|
|
StreamWriter outFile = new StreamWriter( filePath, false, Encoding.ASCII );
|
|
|
|
if( ms_bindings.Count > 0 )
|
|
{
|
|
lock( ms_bindings )
|
|
{
|
|
List<string> bindings = GetAllBindings();
|
|
|
|
foreach( string line in bindings )
|
|
{
|
|
outFile.WriteLine( line );
|
|
}
|
|
}
|
|
}
|
|
if( ms_functions.Count > 0 )
|
|
{
|
|
lock( ms_functions )
|
|
{
|
|
List<string> functions = GetAllFunctions();
|
|
|
|
foreach( string line in functions )
|
|
{
|
|
outFile.WriteLine( line );
|
|
}
|
|
}
|
|
}
|
|
outFile.Write( "consoleheight " + m_height );
|
|
outFile.Write( "consolescale " + Scale );
|
|
outFile.Write( "loglimit " + m_logLimit );
|
|
outFile.Close();
|
|
outFile.Dispose();
|
|
|
|
|
|
AddOutputToLog( "State has been saved to: " + filePath );
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_UnBind( string[] cmdLine )
|
|
{
|
|
string bindString = cmdLine[ 1 ];
|
|
Keys bindKey = Keys.None;
|
|
BindingObject.EModifier bindKeyModifiers = BindingObject.EModifier.None;
|
|
bool parsed = GetKeyBindingInfo( bindString, ref bindKeyModifiers, ref bindKey );
|
|
|
|
if( !parsed )
|
|
{
|
|
AddErrorToLog( String.Format( "\"{0}\" was not understood as a proper binding string.", bindString ) );
|
|
return;
|
|
}
|
|
foreach( BindingObject bs in ms_bindings )
|
|
{
|
|
if( ( bindKey == bs._key ) && ( bindKeyModifiers == bs._modifierKeys ) )
|
|
{
|
|
ms_bindings.Remove( bs );
|
|
AddOutputToLog( bs.GetModifierString() + " has been unbound." );
|
|
return;
|
|
}
|
|
}
|
|
AddErrorToLog( bindString + " is not bound." );
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_Bind( string[] cmdLine )
|
|
{
|
|
if( m_bindingsLocked )
|
|
{
|
|
AddErrorToLog( "Binding-related actions have been disabled." );
|
|
return;
|
|
}
|
|
string bindString = cmdLine[ 1 ];
|
|
BindingObject.EModifier bindKeyModifiers = BindingObject.EModifier.None;
|
|
Keys bindKey = Keys.None;
|
|
bool parsed = GetKeyBindingInfo( bindString, ref bindKeyModifiers, ref bindKey );
|
|
|
|
if( !parsed )
|
|
{
|
|
AddErrorToLog( String.Format( "\"{0}\" was not understood as a proper binding string.", bindString ) );
|
|
return;
|
|
}
|
|
foreach( BindingObject bs in ms_bindings )
|
|
{
|
|
if( ( bindKey == bs._key ) && ( bindKeyModifiers == bs._modifierKeys ) )
|
|
{
|
|
AddErrorToLog( String.Format( "{0} is already bound.", bindString ) );
|
|
return;
|
|
}
|
|
}
|
|
BindingObject newBS = new BindingObject();
|
|
string cmds = String.Empty;
|
|
|
|
for( int cmd = 2; cmd < cmdLine.Length; cmd++ )
|
|
{
|
|
cmds += cmdLine[ cmd ];
|
|
cmds += " ";
|
|
}
|
|
newBS._key = bindKey;
|
|
newBS._modifierKeys = bindKeyModifiers;
|
|
newBS._text = cmds;
|
|
|
|
ms_bindings.Add( newBS );
|
|
|
|
return;
|
|
}
|
|
|
|
void CommandConsoleBase_Function( string[] cmdLine )
|
|
{
|
|
if( m_functionsLocked )
|
|
{
|
|
AddErrorToLog( "Function-related actions have been disabled." );
|
|
return;
|
|
}
|
|
string cmds = String.Empty;
|
|
bool isSecret = false;
|
|
|
|
// This Is A Bit Heavyweight, Building A command Line And Then
|
|
// Breaking It Apart Again, But It Seemed Easier And Less
|
|
// Complicated Than Trying To Do It All In One Shot
|
|
//
|
|
// Build Command Line Minus Command And Secret Option
|
|
for( int cmd = 2; cmd < cmdLine.Length; cmd++ )
|
|
{
|
|
if( ( cmd == 2 ) && ( cmdLine[ cmd ].ToLowerInvariant() == "secret" ) )
|
|
{
|
|
isSecret = true;
|
|
continue;
|
|
}
|
|
cmds += cmdLine[ cmd ];
|
|
cmds += " ";
|
|
}
|
|
if( String.IsNullOrWhiteSpace( cmds ) )
|
|
{
|
|
AddErrorToLog( "Function contains no code to execute." );
|
|
return;
|
|
}
|
|
string[] ft = cmds.Split( ';' );
|
|
bool hasCode = false;
|
|
|
|
// Reassemble Command Lines From Tokens
|
|
for( int line = 0; line <ft.Length; line++ )
|
|
{
|
|
ft[ line ] = ft[ line ].Trim().ToLowerInvariant();
|
|
if( ft[ line ].Length == 0 )
|
|
{
|
|
continue;
|
|
}
|
|
hasCode = true;
|
|
}
|
|
if( !hasCode )
|
|
{
|
|
AddErrorToLog( "Function contains no code to execute." );
|
|
}
|
|
else
|
|
{
|
|
FuncObject newFN = new FuncObject( cmdLine[ 1 ], ft );
|
|
|
|
newFN.IsSecret = isSecret;
|
|
AddFunction( newFN );
|
|
}
|
|
return;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|
|
#endif |