MoonSharp

If you are developing the extension, you can build and package it using npm with the following commands:

npm install
npm run compile
npm run package:vsix

The MoonSharp VSCode Debugger extension allows you to debug MoonSharp scripts running inside other applications.

Requirements:

• The host application must be embedding MoonSharp version 1.8.0.0 or later.
• The host application must expose the VSCode debugger extensions.

Supported Features:

• Connecting to a single script object embedded in an application.
• Breakpoints, watches, and local variable inspection.
• self inspection.
• Call stack visualization, including the current coroutine.
• Watches supporting free-formed, side-effect-free expressions.
• Inspection of values, including internal IDs and table contents.

Limitations:

• You cannot debug multiple script objects from the same VSCode instance.
• You cannot edit values during a debug session.
• There are no checks for file content changes.
• Token-based breakpoints are not supported due to VSCode architecture.

To use the debugger, you must create a launch.json file in your VSCode project. You must specify the debugServer port immediately after the version field. This port must match the port the host application is using to expose the debugger.

{
    "version": "0.2.0",
    "debugServer" : 41912,
    "configurations": [
        {
            "name": "MoonSharp Attach",
            "type": "moonsharp-debug",
            "request": "attach",
            "HELP": "Please set 'debugServer':41912 (or whatever port you ar connecting to) right after the 'version' field in this json."
        }
    ]
}

You can install MoonSharp directly into your Unity project by adding it to your Packages/manifest.json file.

Install specific version

Add the following entry to your dependencies object: "org.moonsharp.moonsharp": "https://github.com/moonsharp-devs/moonsharp.git?path=/interpreter#upm/v3.0"

Pin to a major version

To pin to a major version (e.g., version 3) instead of a specific minor version, use the branch upm/v3.

Install the VSCode Debugger

The VSCode debugger is a separate package. Add it to manifest.json using: "org.moonsharp.debugger.vscode": "https://github.com/moonsharp-devs/moonsharp.git?path=/debugger/vscode#upm/v3.0"

Beta versions

Beta branches follow the naming convention upm/beta/v3.0.

To create a local tarball of the MoonSharp Unity Package, run the following commands from the repository root:

1. Stage the local package using the provided script.
2. Navigate to the staged directory.
3. Use npm pack to generate the .tgz file.

Note: Replace 3.0.0-local with your desired version string.

tools/upm/stage-local-package.sh 3.0.0-local
cd .upm-staging/org.moonsharp.moonsharp
npm pack

To execute Lua code within a C# application, use the Script.RunString method. The result is returned as a DynValue, which can then be converted to native C# types (such as double, int, or string).

double MoonSharpFactorial()
{
	string script = @"    
		-- defines a factorial function
		function fact (n)
			if (n == 0) then
				return 1
			else
				return n*fact(n - 1)
			end
		end

	return fact(5)";

	DynValue res = Script.RunString(script);
	return res.Number;
}

The CommandManager class is responsible for managing the lifecycle and execution of commands within the MoonSharp REPL or CLI environment. It uses an internal registry of objects implementing the ICommand interface.

To use the command system, you must first call Initialize() to scan the executing assembly and register all available non-abstract classes that implement ICommand. Once initialized, you can execute command strings via Execute or retrieve available commands using GetCommands or Find.