1505 lines
52 KiB
C#
1505 lines
52 KiB
C#
#if UNITY_EDITOR || UNITY_STANDALONE
|
|
// Unity's Text component doesn't render <b> tag correctly on mobile devices
|
|
#define USE_BOLD_COMMAND_SIGNATURES
|
|
#endif
|
|
|
|
using UnityEngine;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using Object = UnityEngine.Object;
|
|
#if UNITY_EDITOR && UNITY_2021_1_OR_NEWER
|
|
using SystemInfo = UnityEngine.Device.SystemInfo; // To support Device Simulator on Unity 2021.1+
|
|
#endif
|
|
|
|
// Manages the console commands, parses console input and handles execution of commands
|
|
// Supported method parameter types: int, float, bool, string, Vector2, Vector3, Vector4
|
|
|
|
// Helper class to store important information about a command
|
|
namespace IngameDebugConsole
|
|
{
|
|
public class ConsoleMethodInfo
|
|
{
|
|
public readonly MethodInfo method;
|
|
public readonly Type[] parameterTypes;
|
|
public readonly object instance;
|
|
|
|
public readonly string command;
|
|
public readonly string signature;
|
|
public readonly string[] parameters;
|
|
|
|
public ConsoleMethodInfo( MethodInfo method, Type[] parameterTypes, object instance, string command, string signature, string[] parameters )
|
|
{
|
|
this.method = method;
|
|
this.parameterTypes = parameterTypes;
|
|
this.instance = instance;
|
|
this.command = command;
|
|
this.signature = signature;
|
|
this.parameters = parameters;
|
|
}
|
|
|
|
public bool IsValid()
|
|
{
|
|
if( !method.IsStatic && ( instance == null || instance.Equals( null ) ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static class DebugLogConsole
|
|
{
|
|
public delegate bool ParseFunction( string input, out object output );
|
|
|
|
// All the commands
|
|
private static readonly List<ConsoleMethodInfo> methods = new List<ConsoleMethodInfo>();
|
|
private static readonly List<ConsoleMethodInfo> matchingMethods = new List<ConsoleMethodInfo>( 4 );
|
|
|
|
// All the parse functions
|
|
private static readonly Dictionary<Type, ParseFunction> parseFunctions = new Dictionary<Type, ParseFunction>()
|
|
{
|
|
{ typeof( string ), ParseString },
|
|
{ typeof( bool ), ParseBool },
|
|
{ typeof( int ), ParseInt },
|
|
{ typeof( uint ), ParseUInt },
|
|
{ typeof( long ), ParseLong },
|
|
{ typeof( ulong ), ParseULong },
|
|
{ typeof( byte ), ParseByte },
|
|
{ typeof( sbyte ), ParseSByte },
|
|
{ typeof( short ), ParseShort },
|
|
{ typeof( ushort ), ParseUShort },
|
|
{ typeof( char ), ParseChar },
|
|
{ typeof( float ), ParseFloat },
|
|
{ typeof( double ), ParseDouble },
|
|
{ typeof( decimal ), ParseDecimal },
|
|
{ typeof( Vector2 ), ParseVector2 },
|
|
{ typeof( Vector3 ), ParseVector3 },
|
|
{ typeof( Vector4 ), ParseVector4 },
|
|
{ typeof( Quaternion ), ParseQuaternion },
|
|
{ typeof( Color ), ParseColor },
|
|
{ typeof( Color32 ), ParseColor32 },
|
|
{ typeof( Rect ), ParseRect },
|
|
{ typeof( RectOffset ), ParseRectOffset },
|
|
{ typeof( Bounds ), ParseBounds },
|
|
{ typeof( GameObject ), ParseGameObject },
|
|
#if UNITY_2017_2_OR_NEWER
|
|
{ typeof( Vector2Int ), ParseVector2Int },
|
|
{ typeof( Vector3Int ), ParseVector3Int },
|
|
{ typeof( RectInt ), ParseRectInt },
|
|
{ typeof( BoundsInt ), ParseBoundsInt },
|
|
#endif
|
|
};
|
|
|
|
// All the readable names of accepted types
|
|
private static readonly Dictionary<Type, string> typeReadableNames = new Dictionary<Type, string>()
|
|
{
|
|
{ typeof( string ), "String" },
|
|
{ typeof( bool ), "Boolean" },
|
|
{ typeof( int ), "Integer" },
|
|
{ typeof( uint ), "Unsigned Integer" },
|
|
{ typeof( long ), "Long" },
|
|
{ typeof( ulong ), "Unsigned Long" },
|
|
{ typeof( byte ), "Byte" },
|
|
{ typeof( sbyte ), "Short Byte" },
|
|
{ typeof( short ), "Short" },
|
|
{ typeof( ushort ), "Unsigned Short" },
|
|
{ typeof( char ), "Char" },
|
|
{ typeof( float ), "Float" },
|
|
{ typeof( double ), "Double" },
|
|
{ typeof( decimal ), "Decimal" }
|
|
};
|
|
|
|
// Split arguments of an entered command
|
|
private static readonly List<string> commandArguments = new List<string>( 8 );
|
|
|
|
// Command parameter delimeter groups
|
|
private static readonly string[] inputDelimiters = new string[] { "\"\"", "''", "{}", "()", "[]" };
|
|
|
|
// CompareInfo used for case-insensitive command name comparison
|
|
internal static readonly CompareInfo caseInsensitiveComparer = new CultureInfo( "en-US" ).CompareInfo;
|
|
|
|
static DebugLogConsole()
|
|
{
|
|
AddCommand( "help", "Prints all commands", LogAllCommands );
|
|
AddCommand<string>( "help", "Prints all matching commands", LogAllCommandsWithName );
|
|
AddCommand( "sysinfo", "Prints system information", LogSystemInfo );
|
|
|
|
#if UNITY_EDITOR || !NETFX_CORE
|
|
// Find all [ConsoleMethod] functions
|
|
// Don't search built-in assemblies for console methods since they can't have any
|
|
string[] ignoredAssemblies = new string[]
|
|
{
|
|
"Unity",
|
|
"System",
|
|
"Mono.",
|
|
"mscorlib",
|
|
"netstandard",
|
|
"TextMeshPro",
|
|
"Microsoft.GeneratedCode",
|
|
"I18N",
|
|
"Boo.",
|
|
"UnityScript.",
|
|
"ICSharpCode.",
|
|
"ExCSS.Unity",
|
|
#if UNITY_EDITOR
|
|
"Assembly-CSharp-Editor",
|
|
"Assembly-UnityScript-Editor",
|
|
"nunit.",
|
|
"SyntaxTree.",
|
|
"AssetStoreTools",
|
|
#endif
|
|
};
|
|
#endif
|
|
|
|
#if UNITY_EDITOR || !NETFX_CORE
|
|
foreach( Assembly assembly in AppDomain.CurrentDomain.GetAssemblies() )
|
|
#else
|
|
foreach( Assembly assembly in new Assembly[] { typeof( DebugLogConsole ).Assembly } ) // On UWP, at least search this plugin's Assembly for console methods
|
|
#endif
|
|
{
|
|
#if( NET_4_6 || NET_STANDARD_2_0 ) && ( UNITY_EDITOR || !NETFX_CORE )
|
|
if( assembly.IsDynamic )
|
|
continue;
|
|
#endif
|
|
|
|
string assemblyName = assembly.GetName().Name;
|
|
|
|
#if UNITY_EDITOR || !NETFX_CORE
|
|
bool ignoreAssembly = false;
|
|
for( int i = 0; i < ignoredAssemblies.Length; i++ )
|
|
{
|
|
if( caseInsensitiveComparer.IsPrefix( assemblyName, ignoredAssemblies[i], CompareOptions.IgnoreCase ) )
|
|
{
|
|
ignoreAssembly = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( ignoreAssembly )
|
|
continue;
|
|
#endif
|
|
|
|
try
|
|
{
|
|
foreach( Type type in assembly.GetExportedTypes() )
|
|
{
|
|
foreach( MethodInfo method in type.GetMethods( BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly ) )
|
|
{
|
|
foreach( object attribute in method.GetCustomAttributes( typeof( ConsoleMethodAttribute ), false ) )
|
|
{
|
|
ConsoleMethodAttribute consoleMethod = attribute as ConsoleMethodAttribute;
|
|
if( consoleMethod != null )
|
|
AddCommand( consoleMethod.Command, consoleMethod.Description, method, null, consoleMethod.ParameterNames );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch( NotSupportedException ) { }
|
|
catch( System.IO.FileNotFoundException ) { }
|
|
catch( ReflectionTypeLoadException ) { }
|
|
catch( Exception e )
|
|
{
|
|
Debug.LogError( "Couldn't search assembly for [ConsoleMethod] attributes: " + assemblyName + "\n" + e.ToString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Logs the list of available commands
|
|
public static void LogAllCommands()
|
|
{
|
|
int length = 25;
|
|
for( int i = 0; i < methods.Count; i++ )
|
|
{
|
|
if( methods[i].IsValid() )
|
|
length += methods[i].signature.Length + 7;
|
|
}
|
|
|
|
StringBuilder stringBuilder = new StringBuilder( length );
|
|
stringBuilder.Append( "Available commands:" );
|
|
|
|
for( int i = 0; i < methods.Count; i++ )
|
|
{
|
|
if( methods[i].IsValid() )
|
|
stringBuilder.Append( "\n - " ).Append( methods[i].signature );
|
|
}
|
|
|
|
Debug.Log( stringBuilder.ToString() );
|
|
|
|
// After typing help, the log that lists all the commands should automatically be expanded for better UX
|
|
if( DebugLogManager.Instance )
|
|
DebugLogManager.Instance.AdjustLatestPendingLog( true, true );
|
|
}
|
|
|
|
// Logs the list of available commands that are either equal to commandName or contain commandName as substring
|
|
public static void LogAllCommandsWithName( string commandName )
|
|
{
|
|
matchingMethods.Clear();
|
|
|
|
// First, try to find commands that exactly match the commandName. If there are no such commands, try to find
|
|
// commands that contain commandName as substring
|
|
FindCommands( commandName, false, matchingMethods );
|
|
if( matchingMethods.Count == 0 )
|
|
FindCommands( commandName, true, matchingMethods );
|
|
|
|
if( matchingMethods.Count == 0 )
|
|
Debug.LogWarning( string.Concat( "ERROR: can't find command '", commandName, "'" ) );
|
|
else
|
|
{
|
|
int commandsLength = 25;
|
|
for( int i = 0; i < matchingMethods.Count; i++ )
|
|
commandsLength += matchingMethods[i].signature.Length + 7;
|
|
|
|
StringBuilder stringBuilder = new StringBuilder( commandsLength );
|
|
stringBuilder.Append( "Matching commands:" );
|
|
|
|
for( int i = 0; i < matchingMethods.Count; i++ )
|
|
stringBuilder.Append( "\n - " ).Append( matchingMethods[i].signature );
|
|
|
|
Debug.Log( stringBuilder.ToString() );
|
|
|
|
if( DebugLogManager.Instance )
|
|
DebugLogManager.Instance.AdjustLatestPendingLog( true, true );
|
|
}
|
|
}
|
|
|
|
// Logs system information
|
|
public static void LogSystemInfo()
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder( 1024 );
|
|
stringBuilder.Append( "Rig: " ).AppendSysInfoIfPresent( SystemInfo.deviceModel ).AppendSysInfoIfPresent( SystemInfo.processorType )
|
|
.AppendSysInfoIfPresent( SystemInfo.systemMemorySize, "MB RAM" ).Append( SystemInfo.processorCount ).Append( " cores\n" );
|
|
stringBuilder.Append( "OS: " ).Append( SystemInfo.operatingSystem ).Append( "\n" );
|
|
stringBuilder.Append( "GPU: " ).Append( SystemInfo.graphicsDeviceName ).Append( " " ).Append( SystemInfo.graphicsMemorySize )
|
|
.Append( "MB " ).Append( SystemInfo.graphicsDeviceVersion )
|
|
.Append( SystemInfo.graphicsMultiThreaded ? " multi-threaded\n" : "\n" );
|
|
stringBuilder.Append( "Data Path: " ).Append( Application.dataPath ).Append( "\n" );
|
|
stringBuilder.Append( "Persistent Data Path: " ).Append( Application.persistentDataPath ).Append( "\n" );
|
|
stringBuilder.Append( "StreamingAssets Path: " ).Append( Application.streamingAssetsPath ).Append( "\n" );
|
|
stringBuilder.Append( "Temporary Cache Path: " ).Append( Application.temporaryCachePath ).Append( "\n" );
|
|
stringBuilder.Append( "Device ID: " ).Append( SystemInfo.deviceUniqueIdentifier ).Append( "\n" );
|
|
stringBuilder.Append( "Max Texture Size: " ).Append( SystemInfo.maxTextureSize ).Append( "\n" );
|
|
#if UNITY_5_6_OR_NEWER
|
|
stringBuilder.Append( "Max Cubemap Size: " ).Append( SystemInfo.maxCubemapSize ).Append( "\n" );
|
|
#endif
|
|
stringBuilder.Append( "Accelerometer: " ).Append( SystemInfo.supportsAccelerometer ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "Gyro: " ).Append( SystemInfo.supportsGyroscope ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "Location Service: " ).Append( SystemInfo.supportsLocationService ? "supported\n" : "not supported\n" );
|
|
#if !UNITY_2019_1_OR_NEWER
|
|
stringBuilder.Append( "Image Effects: " ).Append( SystemInfo.supportsImageEffects ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "RenderToCubemap: " ).Append( SystemInfo.supportsRenderToCubemap ? "supported\n" : "not supported\n" );
|
|
#endif
|
|
stringBuilder.Append( "Compute Shaders: " ).Append( SystemInfo.supportsComputeShaders ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "Shadows: " ).Append( SystemInfo.supportsShadows ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "Instancing: " ).Append( SystemInfo.supportsInstancing ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "Motion Vectors: " ).Append( SystemInfo.supportsMotionVectors ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "3D Textures: " ).Append( SystemInfo.supports3DTextures ? "supported\n" : "not supported\n" );
|
|
#if UNITY_5_6_OR_NEWER
|
|
stringBuilder.Append( "3D Render Textures: " ).Append( SystemInfo.supports3DRenderTextures ? "supported\n" : "not supported\n" );
|
|
#endif
|
|
stringBuilder.Append( "2D Array Textures: " ).Append( SystemInfo.supports2DArrayTextures ? "supported\n" : "not supported\n" );
|
|
stringBuilder.Append( "Cubemap Array Textures: " ).Append( SystemInfo.supportsCubemapArrayTextures ? "supported" : "not supported" );
|
|
|
|
Debug.Log( stringBuilder.ToString() );
|
|
|
|
// After typing sysinfo, the log that lists system information should automatically be expanded for better UX
|
|
if( DebugLogManager.Instance )
|
|
DebugLogManager.Instance.AdjustLatestPendingLog( true, true );
|
|
}
|
|
|
|
private static StringBuilder AppendSysInfoIfPresent( this StringBuilder sb, string info, string postfix = null )
|
|
{
|
|
if( info != SystemInfo.unsupportedIdentifier )
|
|
{
|
|
sb.Append( info );
|
|
|
|
if( postfix != null )
|
|
sb.Append( postfix );
|
|
|
|
sb.Append( " " );
|
|
}
|
|
|
|
return sb;
|
|
}
|
|
|
|
private static StringBuilder AppendSysInfoIfPresent( this StringBuilder sb, int info, string postfix = null )
|
|
{
|
|
if( info > 0 )
|
|
{
|
|
sb.Append( info );
|
|
|
|
if( postfix != null )
|
|
sb.Append( postfix );
|
|
|
|
sb.Append( " " );
|
|
}
|
|
|
|
return sb;
|
|
}
|
|
|
|
// Add a custom Type to the list of recognized command parameter Types
|
|
public static void AddCustomParameterType( Type type, ParseFunction parseFunction, string typeReadableName = null )
|
|
{
|
|
if( type == null )
|
|
{
|
|
Debug.LogError( "Parameter type can't be null!" );
|
|
return;
|
|
}
|
|
else if( parseFunction == null )
|
|
{
|
|
Debug.LogError( "Parameter parseFunction can't be null!" );
|
|
return;
|
|
}
|
|
|
|
parseFunctions[type] = parseFunction;
|
|
|
|
if( !string.IsNullOrEmpty( typeReadableName ) )
|
|
typeReadableNames[type] = typeReadableName;
|
|
}
|
|
|
|
// Remove a custom Type from the list of recognized command parameter Types
|
|
public static void RemoveCustomParameterType( Type type )
|
|
{
|
|
parseFunctions.Remove( type );
|
|
typeReadableNames.Remove( type );
|
|
}
|
|
|
|
// Add a command related with an instance method (i.e. non static method)
|
|
public static void AddCommandInstance( string command, string description, string methodName, object instance, params string[] parameterNames )
|
|
{
|
|
if( instance == null )
|
|
{
|
|
Debug.LogError( "Instance can't be null!" );
|
|
return;
|
|
}
|
|
|
|
AddCommand( command, description, methodName, instance.GetType(), instance, parameterNames );
|
|
}
|
|
|
|
// Add a command related with a static method (i.e. no instance is required to call the method)
|
|
public static void AddCommandStatic( string command, string description, string methodName, Type ownerType, params string[] parameterNames )
|
|
{
|
|
AddCommand( command, description, methodName, ownerType, null, parameterNames );
|
|
}
|
|
|
|
// Add a command that can be related to either a static or an instance method
|
|
public static void AddCommand( string command, string description, Action method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1>( string command, string description, Action<T1> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1>( string command, string description, Func<T1> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2>( string command, string description, Action<T1, T2> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2>( string command, string description, Func<T1, T2> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2, T3>( string command, string description, Action<T1, T2, T3> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2, T3>( string command, string description, Func<T1, T2, T3> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2, T3, T4>( string command, string description, Action<T1, T2, T3, T4> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2, T3, T4>( string command, string description, Func<T1, T2, T3, T4> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand<T1, T2, T3, T4, T5>( string command, string description, Func<T1, T2, T3, T4, T5> method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
public static void AddCommand( string command, string description, Delegate method ) { AddCommand( command, description, method.Method, method.Target, null ); }
|
|
|
|
// Add a command with custom parameter names
|
|
public static void AddCommand<T1>( string command, string description, Action<T1> method, string parameterName ) { AddCommand( command, description, method.Method, method.Target, new string[1] { parameterName } ); }
|
|
public static void AddCommand<T1, T2>( string command, string description, Action<T1, T2> method, string parameterName1, string parameterName2 ) { AddCommand( command, description, method.Method, method.Target, new string[2] { parameterName1, parameterName2 } ); }
|
|
public static void AddCommand<T1, T2>( string command, string description, Func<T1, T2> method, string parameterName ) { AddCommand( command, description, method.Method, method.Target, new string[1] { parameterName } ); }
|
|
public static void AddCommand<T1, T2, T3>( string command, string description, Action<T1, T2, T3> method, string parameterName1, string parameterName2, string parameterName3 ) { AddCommand( command, description, method.Method, method.Target, new string[3] { parameterName1, parameterName2, parameterName3 } ); }
|
|
public static void AddCommand<T1, T2, T3>( string command, string description, Func<T1, T2, T3> method, string parameterName1, string parameterName2 ) { AddCommand( command, description, method.Method, method.Target, new string[2] { parameterName1, parameterName2 } ); }
|
|
public static void AddCommand<T1, T2, T3, T4>( string command, string description, Action<T1, T2, T3, T4> method, string parameterName1, string parameterName2, string parameterName3, string parameterName4 ) { AddCommand( command, description, method.Method, method.Target, new string[4] { parameterName1, parameterName2, parameterName3, parameterName4 } ); }
|
|
public static void AddCommand<T1, T2, T3, T4>( string command, string description, Func<T1, T2, T3, T4> method, string parameterName1, string parameterName2, string parameterName3 ) { AddCommand( command, description, method.Method, method.Target, new string[3] { parameterName1, parameterName2, parameterName3 } ); }
|
|
public static void AddCommand<T1, T2, T3, T4, T5>( string command, string description, Func<T1, T2, T3, T4, T5> method, string parameterName1, string parameterName2, string parameterName3, string parameterName4 ) { AddCommand( command, description, method.Method, method.Target, new string[4] { parameterName1, parameterName2, parameterName3, parameterName4 } ); }
|
|
public static void AddCommand( string command, string description, Delegate method, params string[] parameterNames ) { AddCommand( command, description, method.Method, method.Target, parameterNames ); }
|
|
|
|
// Create a new command and set its properties
|
|
private static void AddCommand( string command, string description, string methodName, Type ownerType, object instance, string[] parameterNames )
|
|
{
|
|
// Get the method from the class
|
|
MethodInfo method = ownerType.GetMethod( methodName, BindingFlags.Public | BindingFlags.NonPublic | ( instance != null ? BindingFlags.Instance : BindingFlags.Static ) );
|
|
if( method == null )
|
|
{
|
|
Debug.LogError( methodName + " does not exist in " + ownerType );
|
|
return;
|
|
}
|
|
|
|
AddCommand( command, description, method, instance, parameterNames );
|
|
}
|
|
|
|
private static void AddCommand( string command, string description, MethodInfo method, object instance, string[] parameterNames )
|
|
{
|
|
if( string.IsNullOrEmpty( command ) )
|
|
{
|
|
Debug.LogError( "Command name can't be empty!" );
|
|
return;
|
|
}
|
|
|
|
command = command.Trim();
|
|
if( command.IndexOf( ' ' ) >= 0 )
|
|
{
|
|
Debug.LogError( "Command name can't contain whitespace: " + command );
|
|
return;
|
|
}
|
|
|
|
// Fetch the parameters of the class
|
|
ParameterInfo[] parameters = method.GetParameters();
|
|
if( parameters == null )
|
|
parameters = new ParameterInfo[0];
|
|
|
|
// Store the parameter types in an array
|
|
Type[] parameterTypes = new Type[parameters.Length];
|
|
for( int i = 0; i < parameters.Length; i++ )
|
|
{
|
|
if( parameters[i].ParameterType.IsByRef )
|
|
{
|
|
Debug.LogError( "Command can't have 'out' or 'ref' parameters" );
|
|
return;
|
|
}
|
|
|
|
Type parameterType = parameters[i].ParameterType;
|
|
if( parseFunctions.ContainsKey( parameterType ) || typeof( Component ).IsAssignableFrom( parameterType ) || parameterType.IsEnum || IsSupportedArrayType( parameterType ) )
|
|
parameterTypes[i] = parameterType;
|
|
else
|
|
{
|
|
Debug.LogError( string.Concat( "Parameter ", parameters[i].Name, "'s Type ", parameterType, " isn't supported" ) );
|
|
return;
|
|
}
|
|
}
|
|
|
|
int commandIndex = FindCommandIndex( command );
|
|
if( commandIndex < 0 )
|
|
commandIndex = ~commandIndex;
|
|
else
|
|
{
|
|
int commandFirstIndex = commandIndex;
|
|
int commandLastIndex = commandIndex;
|
|
|
|
while( commandFirstIndex > 0 && caseInsensitiveComparer.Compare( methods[commandFirstIndex - 1].command, command, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
commandFirstIndex--;
|
|
while( commandLastIndex < methods.Count - 1 && caseInsensitiveComparer.Compare( methods[commandLastIndex + 1].command, command, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
commandLastIndex++;
|
|
|
|
commandIndex = commandFirstIndex;
|
|
for( int i = commandFirstIndex; i <= commandLastIndex; i++ )
|
|
{
|
|
int parameterCountDiff = methods[i].parameterTypes.Length - parameterTypes.Length;
|
|
if( parameterCountDiff <= 0 )
|
|
{
|
|
// We are sorting the commands in 2 steps:
|
|
// 1: Sorting by their 'command' names which is handled by FindCommandIndex
|
|
// 2: Sorting by their parameter counts which is handled here (parameterCountDiff <= 0)
|
|
commandIndex = i + 1;
|
|
|
|
// Check if this command has been registered before and if it is, overwrite that command
|
|
if( parameterCountDiff == 0 )
|
|
{
|
|
int j = 0;
|
|
while( j < parameterTypes.Length && parameterTypes[j] == methods[i].parameterTypes[j] )
|
|
j++;
|
|
|
|
if( j >= parameterTypes.Length )
|
|
{
|
|
commandIndex = i;
|
|
commandLastIndex--;
|
|
methods.RemoveAt( i-- );
|
|
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Create the command
|
|
StringBuilder methodSignature = new StringBuilder( 256 );
|
|
string[] parameterSignatures = new string[parameterTypes.Length];
|
|
|
|
#if USE_BOLD_COMMAND_SIGNATURES
|
|
methodSignature.Append( "<b>" );
|
|
#endif
|
|
methodSignature.Append( command );
|
|
|
|
if( parameterTypes.Length > 0 )
|
|
{
|
|
methodSignature.Append( " " );
|
|
|
|
for( int i = 0; i < parameterTypes.Length; i++ )
|
|
{
|
|
int parameterSignatureStartIndex = methodSignature.Length;
|
|
|
|
methodSignature.Append( "[" ).Append( GetTypeReadableName( parameterTypes[i] ) ).Append( " " ).Append( ( parameterNames != null && i < parameterNames.Length && !string.IsNullOrEmpty( parameterNames[i] ) ) ? parameterNames[i] : parameters[i].Name ).Append( "]" );
|
|
|
|
if( i < parameterTypes.Length - 1 )
|
|
methodSignature.Append( " " );
|
|
|
|
parameterSignatures[i] = methodSignature.ToString( parameterSignatureStartIndex, methodSignature.Length - parameterSignatureStartIndex );
|
|
}
|
|
}
|
|
|
|
#if USE_BOLD_COMMAND_SIGNATURES
|
|
methodSignature.Append( "</b>" );
|
|
#endif
|
|
|
|
if( !string.IsNullOrEmpty( description ) )
|
|
methodSignature.Append( ": " ).Append( description );
|
|
|
|
methods.Insert( commandIndex, new ConsoleMethodInfo( method, parameterTypes, instance, command, methodSignature.ToString(), parameterSignatures ) );
|
|
}
|
|
|
|
// Remove all commands with the matching command name from the console
|
|
public static void RemoveCommand( string command )
|
|
{
|
|
if( !string.IsNullOrEmpty( command ) )
|
|
{
|
|
for( int i = methods.Count - 1; i >= 0; i-- )
|
|
{
|
|
if( caseInsensitiveComparer.Compare( methods[i].command, command, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
methods.RemoveAt( i );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Remove all commands with the matching method from the console
|
|
public static void RemoveCommand( Action method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1>( Action<T1> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1>( Func<T1> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2>( Action<T1, T2> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2>( Func<T1, T2> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2, T3>( Action<T1, T2, T3> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2, T3>( Func<T1, T2, T3> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2, T3, T4>( Action<T1, T2, T3, T4> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2, T3, T4>( Func<T1, T2, T3, T4> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand<T1, T2, T3, T4, T5>( Func<T1, T2, T3, T4, T5> method ) { RemoveCommand( method.Method ); }
|
|
public static void RemoveCommand( Delegate method ) { RemoveCommand( method.Method ); }
|
|
|
|
public static void RemoveCommand( MethodInfo method )
|
|
{
|
|
if( method != null )
|
|
{
|
|
for( int i = methods.Count - 1; i >= 0; i-- )
|
|
{
|
|
if( methods[i].method == method )
|
|
methods.RemoveAt( i );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Returns the first command that starts with the entered argument
|
|
public static string GetAutoCompleteCommand( string commandStart, string previousSuggestion )
|
|
{
|
|
int commandIndex = FindCommandIndex( !string.IsNullOrEmpty( previousSuggestion ) ? previousSuggestion : commandStart );
|
|
if( commandIndex < 0 )
|
|
{
|
|
commandIndex = ~commandIndex;
|
|
return ( commandIndex < methods.Count && caseInsensitiveComparer.IsPrefix( methods[commandIndex].command, commandStart, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) ) ? methods[commandIndex].command : null;
|
|
}
|
|
|
|
// Find the next command that starts with commandStart and is different from previousSuggestion
|
|
for( int i = commandIndex + 1; i < methods.Count; i++ )
|
|
{
|
|
if( caseInsensitiveComparer.Compare( methods[i].command, previousSuggestion, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
continue;
|
|
else if( caseInsensitiveComparer.IsPrefix( methods[i].command, commandStart, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) )
|
|
return methods[i].command;
|
|
else
|
|
break;
|
|
}
|
|
|
|
// Couldn't find a command that follows previousSuggestion and satisfies commandStart, loop back to the beginning of the autocomplete suggestions
|
|
string result = null;
|
|
for( int i = commandIndex - 1; i >= 0 && caseInsensitiveComparer.IsPrefix( methods[i].command, commandStart, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ); i-- )
|
|
result = methods[i].command;
|
|
|
|
return result;
|
|
}
|
|
|
|
// Parse the command and try to execute it
|
|
public static void ExecuteCommand( string command )
|
|
{
|
|
if( command == null )
|
|
return;
|
|
|
|
command = command.Trim();
|
|
|
|
if( command.Length == 0 )
|
|
return;
|
|
|
|
// Split the command's arguments
|
|
commandArguments.Clear();
|
|
FetchArgumentsFromCommand( command, commandArguments );
|
|
|
|
// Find all matching commands
|
|
matchingMethods.Clear();
|
|
bool parameterCountMismatch = false;
|
|
int commandIndex = FindCommandIndex( commandArguments[0] );
|
|
if( commandIndex >= 0 )
|
|
{
|
|
string _command = commandArguments[0];
|
|
|
|
int commandLastIndex = commandIndex;
|
|
while( commandIndex > 0 && caseInsensitiveComparer.Compare( methods[commandIndex - 1].command, _command, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
commandIndex--;
|
|
while( commandLastIndex < methods.Count - 1 && caseInsensitiveComparer.Compare( methods[commandLastIndex + 1].command, _command, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
commandLastIndex++;
|
|
|
|
while( commandIndex <= commandLastIndex )
|
|
{
|
|
if( !methods[commandIndex].IsValid() )
|
|
{
|
|
methods.RemoveAt( commandIndex );
|
|
commandLastIndex--;
|
|
}
|
|
else
|
|
{
|
|
// Check if number of parameters match
|
|
if( methods[commandIndex].parameterTypes.Length == commandArguments.Count - 1 )
|
|
matchingMethods.Add( methods[commandIndex] );
|
|
else
|
|
parameterCountMismatch = true;
|
|
|
|
commandIndex++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( matchingMethods.Count == 0 )
|
|
{
|
|
string _command = commandArguments[0];
|
|
FindCommands( _command, !parameterCountMismatch, matchingMethods );
|
|
|
|
if( matchingMethods.Count == 0 )
|
|
Debug.LogWarning( string.Concat( "ERROR: can't find command '", _command, "'" ) );
|
|
else
|
|
{
|
|
int commandsLength = _command.Length + 75;
|
|
for( int i = 0; i < matchingMethods.Count; i++ )
|
|
commandsLength += matchingMethods[i].signature.Length + 7;
|
|
|
|
StringBuilder stringBuilder = new StringBuilder( commandsLength );
|
|
if( parameterCountMismatch )
|
|
stringBuilder.Append( "ERROR: '" ).Append( _command ).Append( "' doesn't take " ).Append( commandArguments.Count - 1 ).Append( " parameter(s). Available command(s):" );
|
|
else
|
|
stringBuilder.Append( "ERROR: can't find command '" ).Append( _command ).Append( "'. Did you mean:" );
|
|
|
|
for( int i = 0; i < matchingMethods.Count; i++ )
|
|
stringBuilder.Append( "\n - " ).Append( matchingMethods[i].signature );
|
|
|
|
Debug.LogWarning( stringBuilder.ToString() );
|
|
|
|
// The log that lists method signature(s) for this command should automatically be expanded for better UX
|
|
if( DebugLogManager.Instance )
|
|
DebugLogManager.Instance.AdjustLatestPendingLog( true, true );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
ConsoleMethodInfo methodToExecute = null;
|
|
object[] parameters = new object[commandArguments.Count - 1];
|
|
string errorMessage = null;
|
|
for( int i = 0; i < matchingMethods.Count && methodToExecute == null; i++ )
|
|
{
|
|
ConsoleMethodInfo methodInfo = matchingMethods[i];
|
|
|
|
// Parse the parameters into objects
|
|
bool success = true;
|
|
for( int j = 0; j < methodInfo.parameterTypes.Length && success; j++ )
|
|
{
|
|
try
|
|
{
|
|
string argument = commandArguments[j + 1];
|
|
Type parameterType = methodInfo.parameterTypes[j];
|
|
|
|
object val;
|
|
if( ParseArgument( argument, parameterType, out val ) )
|
|
parameters[j] = val;
|
|
else
|
|
{
|
|
success = false;
|
|
errorMessage = string.Concat( "ERROR: couldn't parse ", argument, " to ", GetTypeReadableName( parameterType ) );
|
|
}
|
|
}
|
|
catch( Exception e )
|
|
{
|
|
success = false;
|
|
errorMessage = "ERROR: " + e.ToString();
|
|
}
|
|
}
|
|
|
|
if( success )
|
|
methodToExecute = methodInfo;
|
|
}
|
|
|
|
if( methodToExecute == null )
|
|
Debug.LogWarning( !string.IsNullOrEmpty( errorMessage ) ? errorMessage : "ERROR: something went wrong" );
|
|
else
|
|
{
|
|
// Execute the method associated with the command
|
|
object result = methodToExecute.method.Invoke( methodToExecute.instance, parameters );
|
|
if( methodToExecute.method.ReturnType != typeof( void ) )
|
|
{
|
|
// Print the returned value to the console
|
|
if( result == null || result.Equals( null ) )
|
|
Debug.Log( "Returned: null" );
|
|
else
|
|
Debug.Log( "Returned: " + result.ToString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void FetchArgumentsFromCommand( string command, List<string> commandArguments )
|
|
{
|
|
for( int i = 0; i < command.Length; i++ )
|
|
{
|
|
if( char.IsWhiteSpace( command[i] ) )
|
|
continue;
|
|
|
|
int delimiterIndex = IndexOfDelimiterGroup( command[i] );
|
|
if( delimiterIndex >= 0 )
|
|
{
|
|
int endIndex = IndexOfDelimiterGroupEnd( command, delimiterIndex, i + 1 );
|
|
commandArguments.Add( command.Substring( i + 1, endIndex - i - 1 ) );
|
|
i = ( endIndex < command.Length - 1 && command[endIndex + 1] == ',' ) ? endIndex + 1 : endIndex;
|
|
}
|
|
else
|
|
{
|
|
int endIndex = IndexOfChar( command, ' ', i + 1 );
|
|
commandArguments.Add( command.Substring( i, command[endIndex - 1] == ',' ? endIndex - 1 - i : endIndex - i ) );
|
|
i = endIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void FindCommands( string commandName, bool allowSubstringMatching, List<ConsoleMethodInfo> matchingCommands )
|
|
{
|
|
if( allowSubstringMatching )
|
|
{
|
|
for( int i = 0; i < methods.Count; i++ )
|
|
{
|
|
if( methods[i].IsValid() && caseInsensitiveComparer.IndexOf( methods[i].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) >= 0 )
|
|
matchingCommands.Add( methods[i] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( int i = 0; i < methods.Count; i++ )
|
|
{
|
|
if( methods[i].IsValid() && caseInsensitiveComparer.Compare( methods[i].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
matchingCommands.Add( methods[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finds all commands that have a matching signature with command
|
|
// - caretIndexIncrements: indices inside "string command" that separate two arguments in the command. This is used to
|
|
// figure out which argument the caret is standing on
|
|
// - commandName: command's name (first argument)
|
|
internal static void GetCommandSuggestions( string command, List<ConsoleMethodInfo> matchingCommands, List<int> caretIndexIncrements, ref string commandName, out int numberOfParameters )
|
|
{
|
|
bool commandNameCalculated = false;
|
|
bool commandNameFullyTyped = false;
|
|
numberOfParameters = -1;
|
|
for( int i = 0; i < command.Length; i++ )
|
|
{
|
|
if( char.IsWhiteSpace( command[i] ) )
|
|
continue;
|
|
|
|
int delimiterIndex = IndexOfDelimiterGroup( command[i] );
|
|
if( delimiterIndex >= 0 )
|
|
{
|
|
int endIndex = IndexOfDelimiterGroupEnd( command, delimiterIndex, i + 1 );
|
|
if( !commandNameCalculated )
|
|
{
|
|
commandNameCalculated = true;
|
|
commandNameFullyTyped = command.Length > endIndex;
|
|
|
|
int commandNameLength = endIndex - i - 1;
|
|
if( commandName == null || commandNameLength == 0 || commandName.Length != commandNameLength || caseInsensitiveComparer.IndexOf( command, commandName, i + 1, commandNameLength, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) != i + 1 )
|
|
commandName = command.Substring( i + 1, commandNameLength );
|
|
}
|
|
|
|
i = ( endIndex < command.Length - 1 && command[endIndex + 1] == ',' ) ? endIndex + 1 : endIndex;
|
|
caretIndexIncrements.Add( i + 1 );
|
|
}
|
|
else
|
|
{
|
|
int endIndex = IndexOfChar( command, ' ', i + 1 );
|
|
if( !commandNameCalculated )
|
|
{
|
|
commandNameCalculated = true;
|
|
commandNameFullyTyped = command.Length > endIndex;
|
|
|
|
int commandNameLength = command[endIndex - 1] == ',' ? endIndex - 1 - i : endIndex - i;
|
|
if( commandName == null || commandNameLength == 0 || commandName.Length != commandNameLength || caseInsensitiveComparer.IndexOf( command, commandName, i, commandNameLength, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) != i )
|
|
commandName = command.Substring( i, commandNameLength );
|
|
}
|
|
|
|
i = endIndex;
|
|
caretIndexIncrements.Add( i );
|
|
}
|
|
|
|
numberOfParameters++;
|
|
}
|
|
|
|
if( !commandNameCalculated )
|
|
commandName = string.Empty;
|
|
|
|
if( !string.IsNullOrEmpty( commandName ) )
|
|
{
|
|
int commandIndex = FindCommandIndex( commandName );
|
|
if( commandIndex < 0 )
|
|
commandIndex = ~commandIndex;
|
|
|
|
int commandLastIndex = commandIndex;
|
|
if( !commandNameFullyTyped )
|
|
{
|
|
// Match all commands that start with commandName
|
|
if( commandIndex < methods.Count && caseInsensitiveComparer.IsPrefix( methods[commandIndex].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) )
|
|
{
|
|
while( commandIndex > 0 && caseInsensitiveComparer.IsPrefix( methods[commandIndex - 1].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) )
|
|
commandIndex--;
|
|
while( commandLastIndex < methods.Count - 1 && caseInsensitiveComparer.IsPrefix( methods[commandLastIndex + 1].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) )
|
|
commandLastIndex++;
|
|
}
|
|
else
|
|
commandLastIndex = -1;
|
|
}
|
|
else
|
|
{
|
|
// Match only the commands that are equal to commandName
|
|
if( commandIndex < methods.Count && caseInsensitiveComparer.Compare( methods[commandIndex].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
{
|
|
while( commandIndex > 0 && caseInsensitiveComparer.Compare( methods[commandIndex - 1].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
commandIndex--;
|
|
while( commandLastIndex < methods.Count - 1 && caseInsensitiveComparer.Compare( methods[commandLastIndex + 1].command, commandName, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace ) == 0 )
|
|
commandLastIndex++;
|
|
}
|
|
else
|
|
commandLastIndex = -1;
|
|
}
|
|
|
|
for( ; commandIndex <= commandLastIndex; commandIndex++ )
|
|
{
|
|
if( methods[commandIndex].parameterTypes.Length >= numberOfParameters )
|
|
matchingCommands.Add( methods[commandIndex] );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Find the index of the delimiter group that 'c' belongs to
|
|
private static int IndexOfDelimiterGroup( char c )
|
|
{
|
|
for( int i = 0; i < inputDelimiters.Length; i++ )
|
|
{
|
|
if( c == inputDelimiters[i][0] )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private static int IndexOfDelimiterGroupEnd( string command, int delimiterIndex, int startIndex )
|
|
{
|
|
char startChar = inputDelimiters[delimiterIndex][0];
|
|
char endChar = inputDelimiters[delimiterIndex][1];
|
|
|
|
// Check delimiter's depth for array support (e.g. [[1 2] [3 4]] for Vector2 array)
|
|
int depth = 1;
|
|
|
|
for( int i = startIndex; i < command.Length; i++ )
|
|
{
|
|
char c = command[i];
|
|
if( c == endChar && --depth <= 0 )
|
|
return i;
|
|
else if( c == startChar )
|
|
depth++;
|
|
}
|
|
|
|
return command.Length;
|
|
}
|
|
|
|
// Find the index of char in the string, or return the length of string instead of -1
|
|
private static int IndexOfChar( string command, char c, int startIndex )
|
|
{
|
|
int result = command.IndexOf( c, startIndex );
|
|
if( result < 0 )
|
|
result = command.Length;
|
|
|
|
return result;
|
|
}
|
|
|
|
// Find command's index in the list of registered commands using binary search
|
|
private static int FindCommandIndex( string command )
|
|
{
|
|
int min = 0;
|
|
int max = methods.Count - 1;
|
|
while( min <= max )
|
|
{
|
|
int mid = ( min + max ) / 2;
|
|
int comparison = caseInsensitiveComparer.Compare( command, methods[mid].command, CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace );
|
|
if( comparison == 0 )
|
|
return mid;
|
|
else if( comparison < 0 )
|
|
max = mid - 1;
|
|
else
|
|
min = mid + 1;
|
|
}
|
|
|
|
return ~min;
|
|
}
|
|
|
|
public static bool IsSupportedArrayType( Type type )
|
|
{
|
|
if( type.IsArray )
|
|
{
|
|
if( type.GetArrayRank() != 1 )
|
|
return false;
|
|
|
|
type = type.GetElementType();
|
|
}
|
|
else if( type.IsGenericType )
|
|
{
|
|
if( type.GetGenericTypeDefinition() != typeof( List<> ) )
|
|
return false;
|
|
|
|
type = type.GetGenericArguments()[0];
|
|
}
|
|
else
|
|
return false;
|
|
|
|
return parseFunctions.ContainsKey( type ) || typeof( Component ).IsAssignableFrom( type ) || type.IsEnum;
|
|
}
|
|
|
|
public static string GetTypeReadableName( Type type )
|
|
{
|
|
string result;
|
|
if( typeReadableNames.TryGetValue( type, out result ) )
|
|
return result;
|
|
|
|
if( IsSupportedArrayType( type ) )
|
|
{
|
|
Type elementType = type.IsArray ? type.GetElementType() : type.GetGenericArguments()[0];
|
|
if( typeReadableNames.TryGetValue( elementType, out result ) )
|
|
return result + "[]";
|
|
else
|
|
return elementType.Name + "[]";
|
|
}
|
|
|
|
return type.Name;
|
|
}
|
|
|
|
public static bool ParseArgument( string input, Type argumentType, out object output )
|
|
{
|
|
ParseFunction parseFunction;
|
|
if( parseFunctions.TryGetValue( argumentType, out parseFunction ) )
|
|
return parseFunction( input, out output );
|
|
else if( typeof( Component ).IsAssignableFrom( argumentType ) )
|
|
return ParseComponent( input, argumentType, out output );
|
|
else if( argumentType.IsEnum )
|
|
return ParseEnum( input, argumentType, out output );
|
|
else if( IsSupportedArrayType( argumentType ) )
|
|
return ParseArray( input, argumentType, out output );
|
|
else
|
|
{
|
|
output = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool ParseString( string input, out object output )
|
|
{
|
|
output = input;
|
|
return true;
|
|
}
|
|
|
|
public static bool ParseBool( string input, out object output )
|
|
{
|
|
if( input == "1" || input.ToLowerInvariant() == "true" )
|
|
{
|
|
output = true;
|
|
return true;
|
|
}
|
|
|
|
if( input == "0" || input.ToLowerInvariant() == "false" )
|
|
{
|
|
output = false;
|
|
return true;
|
|
}
|
|
|
|
output = false;
|
|
return false;
|
|
}
|
|
|
|
public static bool ParseInt( string input, out object output )
|
|
{
|
|
int value;
|
|
bool result = int.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseUInt( string input, out object output )
|
|
{
|
|
uint value;
|
|
bool result = uint.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseLong( string input, out object output )
|
|
{
|
|
long value;
|
|
bool result = long.TryParse( !input.EndsWith( "L", StringComparison.OrdinalIgnoreCase ) ? input : input.Substring( 0, input.Length - 1 ), out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseULong( string input, out object output )
|
|
{
|
|
ulong value;
|
|
bool result = ulong.TryParse( !input.EndsWith( "L", StringComparison.OrdinalIgnoreCase ) ? input : input.Substring( 0, input.Length - 1 ), out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseByte( string input, out object output )
|
|
{
|
|
byte value;
|
|
bool result = byte.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseSByte( string input, out object output )
|
|
{
|
|
sbyte value;
|
|
bool result = sbyte.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseShort( string input, out object output )
|
|
{
|
|
short value;
|
|
bool result = short.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseUShort( string input, out object output )
|
|
{
|
|
ushort value;
|
|
bool result = ushort.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseChar( string input, out object output )
|
|
{
|
|
char value;
|
|
bool result = char.TryParse( input, out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseFloat( string input, out object output )
|
|
{
|
|
float value;
|
|
bool result = float.TryParse( !input.EndsWith( "f", StringComparison.OrdinalIgnoreCase ) ? input : input.Substring( 0, input.Length - 1 ), out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseDouble( string input, out object output )
|
|
{
|
|
double value;
|
|
bool result = double.TryParse( !input.EndsWith( "f", StringComparison.OrdinalIgnoreCase ) ? input : input.Substring( 0, input.Length - 1 ), out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseDecimal( string input, out object output )
|
|
{
|
|
decimal value;
|
|
bool result = decimal.TryParse( !input.EndsWith( "f", StringComparison.OrdinalIgnoreCase ) ? input : input.Substring( 0, input.Length - 1 ), out value );
|
|
|
|
output = value;
|
|
return result;
|
|
}
|
|
|
|
public static bool ParseVector2( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Vector2 ), out output );
|
|
}
|
|
|
|
public static bool ParseVector3( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Vector3 ), out output );
|
|
}
|
|
|
|
public static bool ParseVector4( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Vector4 ), out output );
|
|
}
|
|
|
|
public static bool ParseQuaternion( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Quaternion ), out output );
|
|
}
|
|
|
|
public static bool ParseColor( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Color ), out output );
|
|
}
|
|
|
|
public static bool ParseColor32( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Color32 ), out output );
|
|
}
|
|
|
|
public static bool ParseRect( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Rect ), out output );
|
|
}
|
|
|
|
public static bool ParseRectOffset( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( RectOffset ), out output );
|
|
}
|
|
|
|
public static bool ParseBounds( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Bounds ), out output );
|
|
}
|
|
|
|
#if UNITY_2017_2_OR_NEWER
|
|
public static bool ParseVector2Int( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Vector2Int ), out output );
|
|
}
|
|
|
|
public static bool ParseVector3Int( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( Vector3Int ), out output );
|
|
}
|
|
|
|
public static bool ParseRectInt( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( RectInt ), out output );
|
|
}
|
|
|
|
public static bool ParseBoundsInt( string input, out object output )
|
|
{
|
|
return ParseVector( input, typeof( BoundsInt ), out output );
|
|
}
|
|
#endif
|
|
|
|
public static bool ParseGameObject( string input, out object output )
|
|
{
|
|
output = input == "null" ? null : GameObject.Find( input );
|
|
return true;
|
|
}
|
|
|
|
public static bool ParseComponent( string input, Type componentType, out object output )
|
|
{
|
|
GameObject gameObject = input == "null" ? null : GameObject.Find( input );
|
|
output = gameObject ? gameObject.GetComponent( componentType ) : null;
|
|
return true;
|
|
}
|
|
|
|
public static bool ParseEnum( string input, Type enumType, out object output )
|
|
{
|
|
const int NONE = 0, OR = 1, AND = 2;
|
|
|
|
int outputInt = 0;
|
|
int operation = NONE; // 0: nothing, 1: OR with outputInt, 2: AND with outputInt
|
|
for( int i = 0; i < input.Length; i++ )
|
|
{
|
|
string enumStr;
|
|
int orIndex = input.IndexOf( '|', i );
|
|
int andIndex = input.IndexOf( '&', i );
|
|
if( orIndex < 0 )
|
|
enumStr = input.Substring( i, ( andIndex < 0 ? input.Length : andIndex ) - i ).Trim();
|
|
else
|
|
enumStr = input.Substring( i, ( andIndex < 0 ? orIndex : Mathf.Min( andIndex, orIndex ) ) - i ).Trim();
|
|
|
|
int value;
|
|
if( !int.TryParse( enumStr, out value ) )
|
|
{
|
|
try
|
|
{
|
|
// Case-insensitive enum parsing
|
|
value = Convert.ToInt32( Enum.Parse( enumType, enumStr, true ) );
|
|
}
|
|
catch
|
|
{
|
|
output = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if( operation == NONE )
|
|
outputInt = value;
|
|
else if( operation == OR )
|
|
outputInt |= value;
|
|
else
|
|
outputInt &= value;
|
|
|
|
if( orIndex >= 0 )
|
|
{
|
|
if( andIndex > orIndex )
|
|
{
|
|
operation = AND;
|
|
i = andIndex;
|
|
}
|
|
else
|
|
{
|
|
operation = OR;
|
|
i = orIndex;
|
|
}
|
|
}
|
|
else if( andIndex >= 0 )
|
|
{
|
|
operation = AND;
|
|
i = andIndex;
|
|
}
|
|
else
|
|
i = input.Length;
|
|
}
|
|
|
|
output = Enum.ToObject( enumType, outputInt );
|
|
return true;
|
|
}
|
|
|
|
public static bool ParseArray( string input, Type arrayType, out object output )
|
|
{
|
|
List<string> valuesToParse = new List<string>( 2 );
|
|
FetchArgumentsFromCommand( input, valuesToParse );
|
|
|
|
IList result = (IList) Activator.CreateInstance( arrayType, new object[1] { valuesToParse.Count } );
|
|
output = result;
|
|
|
|
if( arrayType.IsArray )
|
|
{
|
|
Type elementType = arrayType.GetElementType();
|
|
for( int i = 0; i < valuesToParse.Count; i++ )
|
|
{
|
|
object obj;
|
|
if( !ParseArgument( valuesToParse[i], elementType, out obj ) )
|
|
return false;
|
|
|
|
result[i] = obj;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Type elementType = arrayType.GetGenericArguments()[0];
|
|
for( int i = 0; i < valuesToParse.Count; i++ )
|
|
{
|
|
object obj;
|
|
if( !ParseArgument( valuesToParse[i], elementType, out obj ) )
|
|
return false;
|
|
|
|
result.Add( obj );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Create a vector of specified type (fill the blank slots with 0 or ignore unnecessary slots)
|
|
private static bool ParseVector( string input, Type vectorType, out object output )
|
|
{
|
|
List<string> tokens = new List<string>( input.Replace( ',', ' ' ).Trim().Split( ' ' ) );
|
|
for( int i = tokens.Count - 1; i >= 0; i-- )
|
|
{
|
|
tokens[i] = tokens[i].Trim();
|
|
if( tokens[i].Length == 0 )
|
|
tokens.RemoveAt( i );
|
|
}
|
|
|
|
float[] tokenValues = new float[tokens.Count];
|
|
for( int i = 0; i < tokens.Count; i++ )
|
|
{
|
|
object val;
|
|
if( !ParseFloat( tokens[i], out val ) )
|
|
{
|
|
if( vectorType == typeof( Vector3 ) )
|
|
output = Vector3.zero;
|
|
else if( vectorType == typeof( Vector2 ) )
|
|
output = Vector2.zero;
|
|
else
|
|
output = Vector4.zero;
|
|
|
|
return false;
|
|
}
|
|
|
|
tokenValues[i] = (float) val;
|
|
}
|
|
|
|
if( vectorType == typeof( Vector3 ) )
|
|
{
|
|
Vector3 result = Vector3.zero;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 3; i++ )
|
|
result[i] = tokenValues[i];
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Vector2 ) )
|
|
{
|
|
Vector2 result = Vector2.zero;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 2; i++ )
|
|
result[i] = tokenValues[i];
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Vector4 ) )
|
|
{
|
|
Vector4 result = Vector4.zero;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 4; i++ )
|
|
result[i] = tokenValues[i];
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Quaternion ) )
|
|
{
|
|
Quaternion result = Quaternion.identity;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 4; i++ )
|
|
result[i] = tokenValues[i];
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Color ) )
|
|
{
|
|
Color result = Color.black;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 4; i++ )
|
|
result[i] = tokenValues[i];
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Color32 ) )
|
|
{
|
|
Color32 result = new Color32( 0, 0, 0, 255 );
|
|
|
|
if( tokenValues.Length > 0 )
|
|
result.r = (byte) Mathf.RoundToInt( tokenValues[0] );
|
|
if( tokenValues.Length > 1 )
|
|
result.g = (byte) Mathf.RoundToInt( tokenValues[1] );
|
|
if( tokenValues.Length > 2 )
|
|
result.b = (byte) Mathf.RoundToInt( tokenValues[2] );
|
|
if( tokenValues.Length > 3 )
|
|
result.a = (byte) Mathf.RoundToInt( tokenValues[3] );
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Rect ) )
|
|
{
|
|
Rect result = Rect.zero;
|
|
|
|
if( tokenValues.Length > 0 )
|
|
result.x = tokenValues[0];
|
|
if( tokenValues.Length > 1 )
|
|
result.y = tokenValues[1];
|
|
if( tokenValues.Length > 2 )
|
|
result.width = tokenValues[2];
|
|
if( tokenValues.Length > 3 )
|
|
result.height = tokenValues[3];
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( RectOffset ) )
|
|
{
|
|
RectOffset result = new RectOffset();
|
|
|
|
if( tokenValues.Length > 0 )
|
|
result.left = Mathf.RoundToInt( tokenValues[0] );
|
|
if( tokenValues.Length > 1 )
|
|
result.right = Mathf.RoundToInt( tokenValues[1] );
|
|
if( tokenValues.Length > 2 )
|
|
result.top = Mathf.RoundToInt( tokenValues[2] );
|
|
if( tokenValues.Length > 3 )
|
|
result.bottom = Mathf.RoundToInt( tokenValues[3] );
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Bounds ) )
|
|
{
|
|
Vector3 center = Vector3.zero;
|
|
for( int i = 0; i < tokenValues.Length && i < 3; i++ )
|
|
center[i] = tokenValues[i];
|
|
|
|
Vector3 size = Vector3.zero;
|
|
for( int i = 3; i < tokenValues.Length && i < 6; i++ )
|
|
size[i - 3] = tokenValues[i];
|
|
|
|
output = new Bounds( center, size );
|
|
}
|
|
#if UNITY_2017_2_OR_NEWER
|
|
else if( vectorType == typeof( Vector3Int ) )
|
|
{
|
|
Vector3Int result = Vector3Int.zero;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 3; i++ )
|
|
result[i] = Mathf.RoundToInt( tokenValues[i] );
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( Vector2Int ) )
|
|
{
|
|
Vector2Int result = Vector2Int.zero;
|
|
|
|
for( int i = 0; i < tokenValues.Length && i < 2; i++ )
|
|
result[i] = Mathf.RoundToInt( tokenValues[i] );
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( RectInt ) )
|
|
{
|
|
RectInt result = new RectInt();
|
|
|
|
if( tokenValues.Length > 0 )
|
|
result.x = Mathf.RoundToInt( tokenValues[0] );
|
|
if( tokenValues.Length > 1 )
|
|
result.y = Mathf.RoundToInt( tokenValues[1] );
|
|
if( tokenValues.Length > 2 )
|
|
result.width = Mathf.RoundToInt( tokenValues[2] );
|
|
if( tokenValues.Length > 3 )
|
|
result.height = Mathf.RoundToInt( tokenValues[3] );
|
|
|
|
output = result;
|
|
}
|
|
else if( vectorType == typeof( BoundsInt ) )
|
|
{
|
|
Vector3Int center = Vector3Int.zero;
|
|
for( int i = 0; i < tokenValues.Length && i < 3; i++ )
|
|
center[i] = Mathf.RoundToInt( tokenValues[i] );
|
|
|
|
Vector3Int size = Vector3Int.zero;
|
|
for( int i = 3; i < tokenValues.Length && i < 6; i++ )
|
|
size[i - 3] = Mathf.RoundToInt( tokenValues[i] );
|
|
|
|
output = new BoundsInt( center, size );
|
|
}
|
|
#endif
|
|
else
|
|
{
|
|
output = null;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
} |