Utilities Quantum Console: The Ultimate in Game Development Console

EDIT: Quantum Console is now live!!
If you own QC, please fill out my survey to help me improve it!

Support: Email | Discord | Issue Tracker | Twitter | Docs | Forum | Demo
Requires TMP and .NET 4.X backend (default)
Quantum Console is a powerful and easy to use in game command console. By simply adding [Command] to your code you can add your own commands and dev cheats to the console!


What can it be used for?
Including, but not limited to:
- Flexible QA tools
- Development cheats for testing
- Debugging assistance
- In game cheat codes
- Adaptable to any project

Command Features:
- Static and non-static commands
- Command overloads and default parameters
- Generic commands
- Async commands
- Supports functions, properties, fields and delegates
- Per command platform black/whitelist
- Easy to use
- Full C# source included

Console Features:
- Display Debug.Log messages in the console
- Highly customisable
- Custom theme system
- Command suggestion and autocompletion
- Text Mesh Pro support

Example Built In Commands:
- man: generates a user manual for a specified command
- exec: compiles an executes C# code at runtime
- #define: defines and creates a user macro
- instantiate: instantiates a copy of an object
- destroy: destroys an object
- get-object-info: gets the transform and component data of an object

Have any queries? Feel free to contact support to help determine if Quantum Console is the solution for you!

Original Post
Allow me to introduce my latest asset, Quantum Console!

​

What does it do?
Quantum Console is an easy to use and powerful in game command console. Simply use the [Command] attribute and you can now use it from inside of your game! Here is a GIF of it in action.

What features does it have?
Here is its current feature set. I would LOVE to add more, so please tell me about any features you desire
- Built in commands (man, help, commands etc)
- Command history, accessible via arrow keys, just like on system command prompts
- Tab auto completion, with a display for the parameter signature of suggested commands
- Support for multiple overloads of the same commands
- Auto overload generation from commands with default parameters

What does it support?
Currently, Quantum Console supports any static function with a few restrictions.
- You cannot have two commands with the same name AND parameter count
- All parameters for the command must be of the supported types (strings, all primitives, vectors, colors, quaternions currently. If you would like to see more types supported, please ask me!)

Fully Customisable
Don't like the default look? The Quantum Console prefab is fully customisable!


How to use it?
Very simple, lets go through an example

Code (CSharp):

1. using QFSW.QC;
2.  
3. public class TestClass
4. {
5.    [Command("test")]
6.    private static void TestFunc(int a = 0, int b = 0) {}
7. }

This will then automatically generate the following commands

Code (CSharp):

1. test
2. test a
3. test a b

It's as simple as that! You can then write

test 3

into the console to use it

How performant is Quantum Console
In order to make it very easy to use for the end user, Quantum Console has to find the commands. Quantum Console generates a table the first time it is used. This will take about 1-2s, but is asynchronous. Performance hit during this will be minimal, but it is a full table generation with error handling and inspection performed. During this generation, the console will display its load status and will not be usable.
Once it has been generated, performance will be very fast, as it creates a direct mapping from commands to actual functions

Any questions? Any suggestions? I'd love to hear what you all think and want to improve it even further!

 

When will this be releasing? It looks pretty useful, as I want to have a quick command system becuase it would be a nice way to save some time so I can focus on other things. Could we make these visible in-game as a cheat/custom mode for players?

 

I aim to release it soon, within a month or so, but I'm not sure

And yes this is possible just make sure to use preprocessors to stop dev commands from appearing in final builds

 

Looks pretty solid! I am looking forward to acquiring this asset to use in my games, specially when testing. Best of luck!

 

Thanks!

 

Back with a new feature!
You can now add descriptions to commands. These will then appear in the user manual generated by the built in man command. For example, here is the manual for man



It's very easy to add! There's two methods. Either

[Command("commandName", "commandDescription")]

or add the

[CommandDescription]

attribute. The latter is useful if you have multiple

[Command]

attributes on a single function!

 

Quantum Console now supports properties!

 

Quantum Console now comes with two new Commands, exec and exec-extern! Here are their manuals

Compiles the given code to C# which will then be executed. Use with caution as no safety checks will be performed. Not supported in builds.

By default, boiler plate code will be inserted around the code you provide. This means various namespaces will be included, and the main class and main function entry point will provided. In this case, the code you provide should be code that would exist within the body of the main function, and thus cannot contain things such as class definition. If you disable boiler plate insertion, you can write whatever code you want, however you must provide a static entry point called Main in a static class called Program


Loads the code at the specified file and compiles it to C# which will then be executed. Use with caution as no safety checks will be performed. Not supported in builds.

By default, boiler plate code will NOT be inserted around the code you provide. Please see 'exec' for more information about boilerplate insertion

 

Quantum Console now supports platform specific commands! You can now white list or blacklist certain platforms with ease!

Code (CSharp):

1. [CommandDescription("test command only available on mac")]
2. [Command("mac-test", Platform.OSXPlayer | Platform.OSXEditor)]
3. private static void MacTest() { }
4.  
5. [CommandDescription("test command only available on windows")]
6. [Command("win-test", Platform.WindowsEditor | Platform.WindowsPlayer)]
7. private static void WinTest() { }
8.  
9. [CommandDescription("test command only available in editors")]
10. [Command("editor-test", Platform.EditorPlatforms)]
11. private static void EditorTest() { }
12.  
13. [CommandDescription("test command available in everything but linux")]
14. [Command("not-linux-test", Platform.AllPlatforms ^ (Platform.LinuxEditor | Platform.LinuxPlayer))]
15. private static void NotLinuxTest() { }

Additionally, you can also use the

[CommandPlatform]

attribute.

Please let me know what you'd like to see next!

 

Fuzzy search is now an option!

If fuzzy search is disabled, then your current search must match the beginning of the command to be suggested (foo*). If fuzzy search is enabled, it can be anywhere within the command name to be suggested (*foo*).

 

Quantum Console has had some massive improvements!
Let's get started

Table generation is massively optimised now. Takes a fraction of a second instead of several (still async) as it now skips Unity and System assemblies

GameObjects and Components are now supported as Command arguments! You have to provide the command with the name of the GO, and it will do the rest itself

Fancy error handling for .NET 3


Vector and color parsing has been improved (predefined colours such as red, blue etc can also be directly used)

Non static commands are now supported for Monobehaviours! You can also use MonoTargetType to control whether it is executed on a single instance or all instances

Added assembly definition files



That's all for today Hope you all enjoy and would love to hear more ideas!

 

Back with more big updates!

Fields are now supported! Adding a [Command] to a field will make it behave as if it were an auto property, no extra code needed!

New mono target Registry has been added! The registry lets you register specific instances of a MonoBehaviour type to the QC, which will then be used by any commands with the Registry MonoTarget; this allows you to have full control over the targets if desired

Preset commands have been added. Utilities like destroy, instantiate etc. These all come in an Extras folder and can easily be removed

Command parameters can now have descriptions! This is added by using the

[CommandParameterDescription]

attribute; said descriptions are included in the manual generated by man

help

command has been added, giving a brief guide to the Quantum Console

Exposed a LogToConsole function on the Quantum Console so that you can add your logs if desired

Additional callbacks such as OnInvoke, OnClear and OnLog have been added

 

I've finally finished remaking the prefab from scratch! This means:

1. It now supports 2017.1+ instead of 2018.2+
2. Prefab looks overall cleaner
3. Much easier to adjust the size and have everything adjust itself properly
4. You can now automatically hide and show the console with hot keys due to the new structure

Hope you all like it! I might be able to finish it up within a week or so Anything else I need to add?

 

Quantum Console is now live!!
Pick it up now for only $20!
https://www.assetstore.unity3d.com/#!/content/128881

 

V1.0.1 has begun development, now supporting delegate fields!
If you add the attribute to a field of a delegate type, it will behave as if it were a normal method

 

V1.0.1 has now been submitted for approval! As well as delegate fields, it also supports enums as parameter types, and comes with more built in commands!

 

Amongst other goodies like nested arrays and more, Quantum Console now supports generic commands!

 

Quantum Console is now getting a brand new demo scene that will be hosted online so you can try before you buy! Check it out!

 

Quantum Console V1.0.2 is now available!

 

Quantum Console now has support for custom themes!


Much more news coming soon, hopefully V1.1.0 will come out Jan 2019, and I'll do a full post on everything new!

 

Namespaces are now supported! Using the command

use-namespace namespaceName

so that you don't have to type them out every time for generic commands!

 

Now with the much requested command suggestion popup display!

 

A brand new demo for QC is now available! Check it out!
https://www.qfsw.co.uk/demos/QC/

 

Quantum Console V2 is finally here! Here is the full whopping changelog!

Code (CSharp):

1. V2.0.0
2. Note: It is recommended you remove Quantum Console from your project before downloading this update
3. Addition 0010: Generic commands are now supported
4. Addition 0011: Macros are now supported
5. Addition 0012: New Quantum Theme system; themes are fully customisable and control formatting of returns
6. Addition 0013: Case sensitivity is now an option for command autocompletion
7. Addition 0014: Optional popup display for suggested commands
8. Addition 0015: Namespace system has been added for type resolution
9. Addition 0016: Nested collections are now supported as arguments
10. Addition 0017: Stacks and Queues are now supported as arguments
11. Addition 0018: Type parser now supports primitives, arrays, generics and namespaces
12. Addition 0019: Type formatter has been massively improved
13. Addition 0020: Formatter now supports Dictionaries and KeyValuePairs
14. Addition 0021: 'null' is now supported as an argument for all reference types
15. Addition 0022: Toggleable timestamps for logs
16. Addition 0023: Autoscrolling feature for the Quantum Console
17. Addition 0024: Improved formatting for inputted commands in the console log
18. Addition 0025: New extra command: add-component
19. Addition 0026: New extra command: teleport-relative
20. Addition 0027: New extra command: set-parent
21. Addition 0028: New extra command: rotate
22. Addition 0029: Brand new demo scene
23. Change 0003: Return serialization has been massively improved
24. Change 0004: Invocation and serialiazation have been decoupled
25. Change 0005: Text processing has been hugely improved, properly supporting escape characters and scope control
26. Change 0006: Color and vector parsing has been improved
27. Change 0007: Scroll sensitivity has been increased
28. Change 0008: Source has been restructured
29. Change 0009: All parsing related functionality has been moved to QuantumParser
30. Change 0010: All registry related functionality has been moved to QuantumMacros
31. Change 0011: Registry commands are now generic
32. Change 0012: Formatting in get-object-info has been improved
33. Change 0013: CTRL and CMD are now one option in keybindings, and SHIFT has been added as a modifier
34. Change 0014: Removed various command aliases
35. Change 0015: exec and exec-extern have been removed from WebGL
36. Bug Fix 0002: Autocompletion sort order for fuzzy searches has been improved
37. Bug Fix 0003: Command history is no longer cleared on console clear
38. Bug Fix 0004: Fixed a bug where 'double' type would be displayed as 'int'
39. Bug Fix 0005: Exception style logs are now formatted correctly
40. Bug Fix 0006: Fixed GetRegistryContents<>
41. Bug Fix 0007: Fixed a bug where writer commands were generated for readonly/const fields
42. Bug Fix 0008: CloseOnSubmit now works
43. Bug Fix 0009: Fixed a bug where commands with unsupported array typed parameters would not be rejected
44. Bug Fix 0010: Fixed a bug where the inspector would throw errors during playmode

 

Quantum Console V2.1.0 is now live! Featuring async command support and much more

Code (CSharp):

1. V2.1.0
2. Addition 0036: Async commands are now fully supported
3. Change 0017: exec and exec-extern are now async commands
4. Change 0018: exec and all related code has been moved to Extras/exec for easy removal if desired
5. Change 0019: exec will no longer appear on iOS, PS4, Switch or Xbox One
6. Bug Fix 0013: Input text no longer becomes highlighted when using the command history
7. Bug Fix 0014: get-object-info command will now throw a proper error on failure
8. Bug Fix 0015: Fixed a bug where TypeFormatters and thus theme objects would be corrupted when moving across specific Unity versions
9.  
10. V2.0.2
11. Addition 0033: Added visibility toggle for scene view mode
12. Addition 0034: QC can now be easily disabled on release builds, builds etc.
13. Addition 0035: Added verbose modes to exception handling and log interception
14.  
15. V2.0.1
16. Addition 0030: Async and thread safe support for logs and Debug.Logs
17. Addition 0031: Option to initialise the console on startup without activating it
18. Addition 0032: Scene persistence option
19. Change 0016: Exposed the Toggle function to the public API
20. Bug Fix 0011: Fixed a bug where logs and Debug.Logs occuring before the console was initialised would be dropped
21. Bug Fix 0012: Stopped editor warnings on 2018.3+

 

V2.1.2 has arrived! The main work has been on internal improvements for performance and capacity, in addition to a fair few extra commands that should help you out. Furthermore, some commands have been upgraded to use async commands

Code (CSharp):

1. Addition 0039: Maximum number of logs can now be restricted
2. Addition 0040: New extra command: enum-info (added enum colouring to default theme)
3. Addition 0041: New extra command: all-scenes
4. Addition 0042: New extra command: loaded-scenes
5. Addition 0043: New extra command: active-scene
6. Addition 0044: New extra command: set-active-scene
7. Addition 0045: New extra command: unload-scene
8. Addition 0046: New extra command: unload-scene-index
9. Addition 0047: New extra command: max-fps
10. Addition 0048: New extra command: vsync
11. Addition 0049: New extra command: set-resolution
12. Addition 0050: New extra command: current-resolutin
13. Addition 0051: New extra command: supported-resolutions
14. Addition 0052: New extra command: fullscreen
15. Addition 0053: New extra command: screen-dpi
16. Addition 0054: New extra command: screen-orientation
17. Addition 0055: New extra command: time-scale
18. Addition 0056: Added MobilePlatforms shortcut to Platform
19. Change 0020: QC no longer needs the .NET 4.6 API compatability level and only the scripting backend
20. Change 0021: QC now internally uses string builders for improved performance
21. Change 0022: Default theme now has IEnumerators default to line seperation and ICollections to [a, b, c]
22. Change 0023: Extra commands now use their own assembly
23. Change 0024: Scene commands have been moved to their own file
24. Change 0025: Scene load/unload commands are now async
25. Bug Fix 0016: Fixed a bug where auto named commands and command prefixes would not work on fields or classes in Rosylyn
26. Bug Fix 0017: Fixed a bug where initialize on startup option would not hide the console
27. Bug Fix 0018: Fixed a bug where whitespace would be treated as args
28. Bug Fix 0019: Fixed the Switch enum value having the incorrect bit value
29. Bug Fix 0020: Fixed .NET auto upgrader

 

V2.2.0 is now live with TMP support!
Let me know what you think and what you want added next!

Code (CSharp):

1. Addition 0060: Added TMP support
2. Addition 0061: Added support for backwards command suggestion cycling
3. Addition 0062: New console command: verbose-errors
4. Addition 0063: New console command: verbose-logging
5. Change 0026: Improved bool parsing to support on/off and 1/0
6. Change 0027: Errors are now more user friendly when using enum arguments
7. Change 0028: Optimised text generation to reduce string size

 

V2.2.1 is here with some massive performance boosts!

Code (CSharp):

1. Addition 0064: New MonoTargetType: Singleton
2. Addition 0065: New extra command: bind
3. Addition 0066: New extra command: unbind
4. Addition 0067: New extra command: unbind-all
5. Addition 0068: New extra command: display-bindings
6. Change 0029: Many parts of Quantum Console have been massively optimised
7. Bug Fix 0022: Fixed a bug where the input field would not focus the first time the console is opened

 

Just getting started with Quantum Console. I've got Input.GetKeyDown() checks in a number of places. Is there a strategy for preventing those from firing while Quantum Console is active and taking events?

Thanks!

 

The way I did it was creating an "Input Module" class which wrapped around the normal input api

This class let me add "blockers", so that if there were any blockers present, input would never trigger

I then subscribed to the QC events OnActivate and OnDeactivate to add and remove the blocker

If you would like some sample code, please let me know @ScottHerz

 

That makes sense. Thanks!

 

Not bad console. Well done!

 

Thanks!

 

Hi, first off this is the best console (how do I spent so much money on consoles). Thank you.

Secondly, have you thought about providing a singleton interface to the QuantumConsole class? I want to invoke the console appearing/disappearing from my own input handling logic, and I have to now carry around a reference in my classes to the QuantumConsole which is OK, but something like QuantumConsole.Instance.Activate() would be cool too (unless there are folks that run multiple consoles?)

 

Thank you for the kind words!

And yes I've considered making it into a singleton. It has its pros but some folks are very dissuaded by singletons so I'm still on the fence

What you could do is make singleton wrapper. i.e a script that is a singleton, sits on the QC instance and has a reference to QC. That way if you want to access it from anywhere you can use the singleton wrapper, but doesn't force QC itself to be a singleton?

If you need any assistance with that I can help write it this evening/tomorrow (taking the day off for Eid with my family)

Thanks!
QFSW

 

Don't worry about writing anything, the reference is fine for me, just a thought.

One piece of feedback: you invoke the OnDeactivate event in two places you shouldn't (in my opinion): in your OnDisable and OnEnable.

I have logic that blocks all input / releases cursor (its an FPS) when the console is shown, and hides the cursor when the console is hidden. When it hides+locks the cursor in OnDisable (as a result of OnDeactivate) it actually persists into the Unity Editor interface! Meaning my mouse is locked (but visible) to the center of the Game panel until I hit escape (Play mode has quit ). This is probably a bug with Unity, but in reality I don't see what the OnDeactivate in OnDisable will really give: any component needs to remove its event subscription in its own OnDisable anyways, it should be able to cleanup itself there.

The OnEnable instance of OnDeactivate is just weird, it doesn't cause bad behaviour but having OnDeactivate is a bit smelly.

I have commented out both calls here, and everything is still working fine.

 

Thanks for the feedback! I'll do some investigation to see if there was any point of having them, and remove them accordingly for the next update

If you're enjoying Quantum Console I would appreciate a review

Thanks

 

Will do. Also, one laaast thing about the documentation: I know its trivial to find in QuantumConsole.cs, but before you even talk about Command attributes, it would be useful to just have a note about "QuantumConsole has its own input handling code for showing and hiding the console. If you'd like to handle the console lifecycle yourself, use the QuantumConsole.Activate() and QuantumConsole.Deactivate() methods". You'll probably write it better than me, but a reference there is useful

 

I'm actually planning on a full overhaul of the documentation system to have a mix of pre-written pages, api references etc more similar to how unity does their documentation (not as huge, with more introductory stuff), so I'll try to get it all in there with a better landing page etc

The reason I put command stuff first in this documentation was because it's the first thing you'd want for a "minimal setup"

 

V2.2.2 is here! With a brand new look, improved non static support and extra commands its got it all!

Code (CSharp):

1. V2.2.2
2. Addition 0064: Quantum Console now has a brand new look
3. Addition 0065: Non static commands can now be used on non-monobehaviours (Quantum Registry must be used)
4. Addition 0066: Formatting in registry errors is now greatly improved
5. Addition 0067: Quantum Theme can now take a custom material and color
6. Addition 0068: Quantum Console can now be dragged (default shift + click)
7. Addition 0069: New extra command: start-coroutine
8. Addition 0070: New extra command: msaa
9. Change 0029: Improved readability of collection formatters on dark theme
10. Change 0030: Improved readability Quantum Theme inspector on dark theme
11. Change 0031: Improved extra command get-object-info
12. Bug Fix 0022: Improved stability of TMP upgrader
13. Bug Fix 0023: Fixed stability issues with theme application
14. Bug Fix 0024: Fixed a bug where QC would complain about weak delegates even if they were not being used as a command

 

In the near future, 2018.3 and TMP may become a requirement for QC, so that it will always run in TMP mode. This will help solve tons of issues with imports and assemblies but will of course mean you now need 2018.3 to use QC. Is this okay? Please let me know if it isn't!

 

Hi everyone, we've had some reports of the following error breaking QC

Code (CSharp):

1. BadImageFormatException: VAR 3 (TOutput) cannot be expanded in this context with 3 instantiations

I can't reproduce it yet myself, but we are investigating it here https://bitbucket.org/QFSW/quantum-console/issues/67/add-protection-against-corrupt-dlls

If you get this issue please let me know and I will send over a hotfix that handles the error more gracefully

 

QC now scans assemblies in parallel, allowing for huge speedups in table generation, with my tests showing up to a 6x speed boost!

 

Quantum Console now has a completely user extensible serialization system, debuting in V2.3.0! You can read more here
https://bitbucket.org/QFSW/quantum-console/issues/45/custom-formatter-support

 

Feature request #1: I would like the ability to dynamically enable and disable commands. The way I would envision this working is that you can add an attribute to a command, or a whole static class containing commands, called something like CommandGroup("Advanced"). That will assign a group name to the commands which will be used later.

Then on QuantumConsoleProcessor you add a method like EnableCommandGroup("Advanced", false) which will take all commands in the specified group and enable/disable them. This will rebuild the command table so that the specified commands are prevented from running, and also don't display for help, it is like they don't exist. This can be used to eliminate commands that don't apply to the current context (e.g. don't work in the current game mode), and also to enable/disable debug/developer commands.

Feature request #2: I would like to be able to hide commands. Add another method to QuantumConsoleProcessor, HideCommandGroup("Unlock", true) which simply prevents the command from showing in auto-complete and the help. You can still execute the command though. You can use this to add secret commands for debugging, and also combining it with #1, to unlock a group of commands e.g. make a command called "unlock" that you can call with "unlock debug" and it unlocks those commands - you could also give it a password or whatever.

These features are pretty easy to add myself but I thought they might be useful for other people so I suggest them.

 

I like the ideas you've suggested. The main difference if I implemented it would be not rebuilding the table but filtering commands when invoked/displayed (for performance reason)

I like to keep track of issues and features on my issue tracker, do you mind if I copy it there verbatim?
https://bitbucket.org/QFSW/quantum-console/issues?status=new&status=open

 

It all sounds good to me, thanks. In the future when I have a suggestion/request, would you prefer I post it here or directly to the issue tracker?

 

I'd say it depends on the nature of the request. If it's something very straightforward such as a bug, or a direct function request or something, then the issue tracker is better. The forums allow for more discussion however, so it allows us to discuss it first before deciding what should actually be added

TL;DR either is fine, but if you expect it might warrant some discussion here is better

 

I've created the issue, you can follow it to get any news on it's development or completion
https://bitbucket.org/QFSW/quantum-console/issues/73/command-groups

Whilst this is not particularly high priority, V2.3.0 is quite a large update that will likely take a while anyway, so it may make it into V2.3.0

 

I've created a survey about QC to help gather some feedback and statistics in an organised fashion, if you have 2 minutes to spare I would hugely appreciate it!

https://forms.gle/TZbpg1t6hc6sypZA9