TechbloxModdingAPI/GamecraftModdingAPI/Commands/CommandBuilder.cs
2020-05-15 17:42:04 -04:00

277 lines
9.2 KiB
C#

using System;
using Svelto.ECS;
using GamecraftModdingAPI.Utility;
namespace GamecraftModdingAPI.Commands
{
/// <summary>
/// Custom Command builder.
/// </summary>
public class CommandBuilder
{
private string name;
private string description;
private short parameterCount;
private ICustomCommandEngine commandEngine;
private bool fromExisting = false;
/// <summary>
/// Create a new command builder.
/// </summary>
public CommandBuilder()
{
name = "";
description = null;
parameterCount = -1;
}
/// <summary>
/// Create and return a command builder.
/// </summary>
/// <returns>The builder.</returns>
public static CommandBuilder Builder()
{
return new CommandBuilder();
}
/// <summary>
/// Create a new command builder.
/// </summary>
/// <param name="name">The command name.</param>
/// <param name="description">The command description (shown in help).</param>
public CommandBuilder(string name, string description = null)
{
this.name = name;
this.description = description;
parameterCount = -1;
}
/// <summary>
/// Create and return a command builder.
/// If name and description are provided, this is equivalent to <code>Builder().Name(name).Description(description)</code>
/// </summary>
/// <param name="name">The command name.</param>
/// <param name="description">The command description (shown in help).</param>
/// <returns>The builder.</returns>
public static CommandBuilder Builder(string name, string description = null)
{
return new CommandBuilder(name, description);
}
/// <summary>
/// Name the command.
/// </summary>
/// <returns>The builder.</returns>
/// <param name="name">The command name.</param>
public CommandBuilder Name(string name)
{
this.name = name;
return this;
}
/// <summary>
/// Describe the command.
/// </summary>
/// <returns>The builder.</returns>
/// <param name="description">The command description (shown in help).</param>
public CommandBuilder Description(string description)
{
this.description = description;
return this;
}
/// <summary>
/// Set the action the command performs.
/// </summary>
/// <returns>The builder.</returns>
/// <param name="action">The action to perform when the command is called.</param>
public CommandBuilder Action(Action action)
{
parameterCount = 0;
commandEngine = new SimpleCustomCommandEngine(action, name, description);
return this;
}
/// <summary>
/// Set the action the command performs.
/// </summary>
/// <returns>The builder.</returns>
/// <param name="action">The action to perform when the command is called.</param>
/// <typeparam name="A">The 1st parameter's type.</typeparam>
public CommandBuilder Action<A>(Action<A> action)
{
parameterCount = 1;
commandEngine = new SimpleCustomCommandEngine<A>(action, name, description);
return this;
}
/// <summary>
/// Set the action the command performs.
/// </summary>
/// <returns>The builder.</returns>
/// <param name="action">The action to perform when the command is called.</param>
/// <typeparam name="A">The 1st parameter's type.</typeparam>
/// <typeparam name="B">The 2nd parameter's type.</typeparam>
public CommandBuilder Action<A,B>(Action<A,B> action)
{
parameterCount = 2;
commandEngine = new SimpleCustomCommandEngine<A,B>(action, name, description);
return this;
}
/// <summary>
/// Set the action the command performs.
/// </summary>
/// <returns>The builder.</returns>
/// <param name="action">The action to perform when the command is called.</param>
/// <typeparam name="A">The 1st parameter's type.</typeparam>
/// <typeparam name="B">The 2nd parameter's type.</typeparam>
/// <typeparam name="C">The 3rd parameter's type.</typeparam>
public CommandBuilder Action<A,B,C>(Action<A,B,C> action)
{
parameterCount = 3;
commandEngine = new SimpleCustomCommandEngine<A,B,C>(action, name, description);
return this;
}
/// <summary>
/// Build the command from an existing command.
/// </summary>
/// <returns>The command. Use Invoke() to execute it.</returns>
public SimpleCustomCommandEngine FromExisting()
{
if (string.IsNullOrWhiteSpace(name))
{
throw new InvalidOperationException("Command name must be defined before FromExisting() is called");
}
if (!ExistingCommands.Exists(name))
{
throw new InvalidOperationException("Command cannot be built from existing because it does not exist.");
}
fromExisting = true;
return new SimpleCustomCommandEngine(
() => { ExistingCommands.Call(name); },
name,
description);
}
/// <summary>
/// Build the command from an existing command.
/// </summary>
/// <returns>The command. Use Invoke() to execute it.</returns>
/// <typeparam name="A">The 1st parameter's type.</typeparam>
public SimpleCustomCommandEngine<A> FromExisting<A>()
{
if (string.IsNullOrWhiteSpace(name))
{
throw new InvalidOperationException("Command name must be defined before FromExisting() is called");
}
if (!ExistingCommands.Exists(name))
{
throw new InvalidOperationException("Command cannot be built from existing because it does not exist.");
}
fromExisting = true;
return new SimpleCustomCommandEngine<A>(
(A a) => { ExistingCommands.Call<A>(name, a); },
name,
description);
}
/// <summary>
/// Build the command from an existing command.
/// </summary>
/// <returns>The command. Use Invoke() to execute it.</returns>
/// <typeparam name="A">The 1st parameter's type.</typeparam>
/// <typeparam name="B">The 2nd parameter's type.</typeparam>
public SimpleCustomCommandEngine<A,B> FromExisting<A,B>()
{
if (string.IsNullOrWhiteSpace(name))
{
throw new InvalidOperationException("Command name must be defined before FromExisting() is called");
}
if (!ExistingCommands.Exists(name))
{
throw new InvalidOperationException("Command cannot be built from existing because it does not exist.");
}
fromExisting = true;
return new SimpleCustomCommandEngine<A,B>(
(A a, B b) => { ExistingCommands.Call<A,B>(name, a, b); },
name,
description);
}
/// <summary>
/// Build the command from an existing command.
/// </summary>
/// <returns>The command. Use Invoke() to execute it.</returns>
/// <typeparam name="A">The 1st parameter's type.</typeparam>
/// <typeparam name="B">The 2nd parameter's type.</typeparam>
/// <typeparam name="C">The 3rd parameter's type.</typeparam>
public SimpleCustomCommandEngine<A,B,C> FromExisting<A,B,C>()
{
if (string.IsNullOrWhiteSpace(name))
{
throw new InvalidOperationException("Command name must be defined before FromExisting() is called");
}
if (!ExistingCommands.Exists(name))
{
throw new InvalidOperationException("Command cannot be built from existing because it does not exist.");
}
fromExisting = true;
return new SimpleCustomCommandEngine<A,B,C>(
(A a, B b, C c) => { ExistingCommands.Call<A,B,C>(name, a, b, c); },
name,
description);
}
/// <summary>
/// Build the command.
/// </summary>
/// <returns>The built command.</returns>
/// <param name="register">Automatically register the command with CommandManager.AddCommand()?</param>
public ICustomCommandEngine Build(bool register = true)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new InvalidOperationException("Command name must be defined before Build() is called");
}
if (fromExisting)
{
throw new InvalidOperationException("Command was already built by FromExisting()");
}
if (commandEngine == null)
{
throw new InvalidOperationException("Command action must be defined before Build() is called");
}
if (string.IsNullOrWhiteSpace(description))
{
Logging.LogWarning($"Command {name} was built without a description");
}
if (register)
{
CommandManager.AddCommand(commandEngine);
Logging.MetaDebugLog($"Command {FullName()} was automatically registered");
}
return commandEngine;
}
/// <summary>
/// Get the full command name, in the form [name]::[description]::[# of parameters]
/// </summary>
/// <returns>The name.</returns>
public string FullName()
{
if (string.IsNullOrWhiteSpace(description))
{
return name + "::" + parameterCount;
}
return name + "::" + description + "::" + parameterCount;
}
}
}