public CommandWrapper(CommandDelegate del)
{
if (del == null) {
throw new ArgumentNullException ("del");
}
this.d = del;
}
public Command(CommandDelegate cmd, params string[] names)
{
if (names == null || names.Length < 1)
throw new NotSupportedException();
permission = null;
Names = new List<string>(names);
command = cmd;
}
public bool Register(string Cmd, CommandDelegate Func)
{
if (!Cmds.ContainsKey(Cmd))
Cmds.Add(Cmd, Func);
else
return false;
return true;
}
/// <summary>
/// Add a command to be executed in parallel.
/// </summary>
/// <param name="command">
/// The command to execute. Should be non-null.
/// </param>
/// <exception cref="System.ArgumentNullException"></exception>
public void Add(CommandDelegate command)
{
if (command == null) {
throw new System.ArgumentNullException("command");
}
CommandQueue queue = new CommandQueue();
queue.Enqueue(command);
_queues.AddLast(queue);
}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name = "command">The string that will make the command execute</param>
/// <param name = "commandHelp">The message that will show the user how to use the command</param>
/// <param name = "info">Any information about how the command works or what it does</param>
/// <param name = "fn"></param>
public void AddCommand(string command, string commandHelp, string infomessage, CommandDelegate fn)
{
CommandInfo info = new CommandInfo{
command = command,
commandHelp = commandHelp,
info = infomessage,
fn = new List<CommandDelegate> {fn}
};
tree.AddCommand(info);
}
public void SchumixRegisterHandler(string code, CommandDelegate method, CommandPermission permission = CommandPermission.Normal)
{
if(sIgnoreCommand.IsIgnore(code))
return;
if(CommandMethodMap.ContainsKey(code.ToLower()))
CommandMethodMap[code.ToLower()].Method += method;
else
CommandMethodMap.Add(code.ToLower(), new CommandMethod(method, permission));
}
public SkypeClient()
{
InitializeComponent();
UM_SkypeControlAPIDiscover = Platform.RegisterWindowMessage(Constants.SkypeControlAPIDiscover);
UM_SkypeControlAPIAttach = Platform.RegisterWindowMessage(Constants.SkypeControlAPIAttach);
commandDelegate += Command;
CreateHandle();
}
public static void RegisterCommandHandler(string command, CommandDelegate handler)
{
try
{
handlers.Add(command, handler);
}
catch (ArgumentException)
{
Debug.Log("An element with Key = " + command + " already exists.");
}
}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="command">The string that will make the command execute</param>
/// <param name="commandHelp">The message that will show the user how to use the command</param>
/// <param name="infomessage">Any information about how the command works or what it does</param>
/// <param name="fn"></param>
/// <param name="requiresAScene">Whether this command requires a scene to be fired</param>
/// <param name="fireOnceForAllScenes">Whether this command will only be executed once if there is no current scene</param>
public void AddCommand (string command, string commandHelp, string infomessage, CommandDelegate fn, bool requiresAScene, bool fireOnceForAllScenes)
{
CommandInfo info = new CommandInfo {
command = command,
commandHelp = commandHelp,
info = infomessage,
fireOnceForAllScenes = fireOnceForAllScenes,
requiresAScene = requiresAScene,
fn = new List<CommandDelegate> { fn }
};
tree.AddCommand (info);
}
public Command(CommandDelegate cmd, params string[] names)
{
if (cmd == null)
throw new ArgumentNullException("cmd");
if (names == null || names.Length < 1)
throw new ArgumentException("names");
AllowServer = true;
CommandDelegate = cmd;
DoLog = true;
HelpText = "No help available.";
Names = new List<string>(names);
Permissions = new List<string>();
}
/// <summary>
/// Creates instance of EJDB.
/// </summary>
/// <param name="library"></param>
public Database(Library library)
{
var libraryHandle = library.LibraryHandle;
DatabaseHandle = new DatabaseHandle(libraryHandle);
Library = library;
_openDatabase = libraryHandle.GetUnmanagedDelegate<OpenDatabaseDelegate>();
_closeDatabase = libraryHandle.GetUnmanagedDelegate<CloseDatabaseDelegate>();
_isOpen = libraryHandle.GetUnmanagedDelegate<IsOpenDelegate>();
_getErrorCode = libraryHandle.GetUnmanagedDelegate<GetErrorCodeDelegate>();
_getMetadata = libraryHandle.GetUnmanagedDelegate<GetMetaDelegate>();
_command = libraryHandle.GetUnmanagedDelegate<CommandDelegate>();
_sync = libraryHandle.GetUnmanagedDelegate<SyncDelegate>();
}
public ProxyFrame(string[] args)
{
bool externalPlugin = false;
this.args = args;
ProxyConfig proxyConfig = new ProxyConfig("SLProxy", "Austin Jennings / Andrew Ortman", args);
proxy = new Proxy(proxyConfig);
// add delegates for login
proxy.SetLoginRequestDelegate(new XmlRpcRequestDelegate(LoginRequest));
proxy.SetLoginResponseDelegate(new XmlRpcResponseDelegate(LoginResponse));
// add a delegate for outgoing chat
proxy.AddDelegate(PacketType.ChatFromViewer, Direction.Outgoing, new PacketDelegate(ChatFromViewerOut));
// handle command line arguments
foreach (string arg in args)
if (arg == "--log-login")
logLogin = true;
else if (arg.Substring(0, 2) == "--")
{
int ipos = arg.IndexOf("=");
if (ipos != -1)
{
string sw = arg.Substring(0, ipos);
string val = arg.Substring(ipos + 1);
Console.WriteLine("arg '" + sw + "' val '" + val + "'");
if (sw == "--load")
{
externalPlugin = true;
LoadPlugin(val);
}
}
}
commandDelegates["/load"] = new CommandDelegate(CmdLoad);
if (!externalPlugin)
{
ProxyPlugin analyst = new Analyst(this);
analyst.Init();
}
}
/// <summary>
/// A Condition command allows branching behaviour. After a condition evaluates to <c>true</c>
/// then onTrue will be evaluated until it finishes. Otherise onFalse will be evaluated, (if it
/// isn't null). When nested in a Repeat command, conditions will be re-evaluated once for every
/// repeat.
/// </summary>
/// <param name="condition">
/// The condition to evaluate. Must be non-null.
/// </param>
/// <param name="onTrue">
/// The command to execute if condition evaluates to true. Must be non-null.
/// </param>
/// <param name="onFalse">
/// The command to execute if condition evaluates to false.
/// </param>
/// <exception cref="System.ArgumentNullException"></exception>
public static CommandDelegate Condition(CommandCondition condition, CommandDelegate onTrue, CommandDelegate onFalse = null)
{
CheckArgumentNonNull(condition, "condition");
CheckArgumentNonNull(onTrue, "onTrue");
CommandDelegate result = onFalse;
return Sequence(
Commands.Do( () => {
result = onFalse;
if (condition()) {
result = onTrue;
}
}),
(ref double deltaTime) => {
if (result != null) {
return result(ref deltaTime);
}
return true;
}
);
}
public DelegateCommand(CommandDelegate execute) : this(execute, null)
{
}
/// <summary>
/// Call this from a region module to add a command to the OpenSim console.
/// </summary>
/// <param name="mod"></param>
/// <param name="command"></param>
/// <param name="shorthelp"></param>
/// <param name="longhelp"></param>
/// <param name="descriptivehelp"></param>
/// <param name="callback"></param>
public void AddCommand(
object mod, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
{
if (MainConsole.Instance == null)
{
return;
}
string modulename = String.Empty;
bool shared = false;
if (mod != null)
{
if (mod is IRegionModule)
{
IRegionModule module = (IRegionModule)mod;
modulename = module.Name;
shared = module.IsSharedModule;
}
else if (mod is IRegionModuleBase)
{
IRegionModuleBase module = (IRegionModuleBase)mod;
modulename = module.Name;
shared = mod is ISharedRegionModule;
}
else
{
throw new Exception("AddCommand module parameter must be IRegionModule or IRegionModuleBase");
}
}
MainConsole.Instance.Commands.AddCommand(
modulename, shared, command, shorthelp, longhelp, descriptivehelp, callback);
}
public static void QueryCommand(CommandDelegate dlgQueryCommand)
{
if (p == null)
{
return;
}
if (p.HasExited)
{
Trace.WriteLine("TS Server は未起動");
return;
}
isDataAnalyzed = false;
ClearDefinitionResult();
ClearReferenceResult();
var pos = Hm.Edit.CursorPos;
var lineno = pos.LineNo;
var column = pos.Column;
if (lineno < 0 || column < 0)
{
return;
}
var winFilePath = Hm.Edit.FilePath;
if (winFilePath == null)
{
Hm.Macro.Var["#RTN_noname"] = 1;
winFilePath = GetWinTempFilePath();
}
var winFilename = System.IO.Path.GetFileName(winFilePath);
// tsserver用にUri形式にする
Uri u = new Uri(winFilePath);
var urlFilePath = u.AbsolutePath;
OpenFileMessage(urlFilePath);
var strTotalText = Hm.Edit.TotalText;
try
{
var winTempPath = GetWinTempFilePath();
WriteWinTempFilePath(strTotalText);
// tsserverが受け付けるuri形式に
Uri uTmp = new Uri(winTempPath);
var urlTempFilePath = uTmp.AbsolutePath;
// リロード
ReloadFileMessage(urlFilePath, urlTempFilePath);
dlgQueryCommand(urlFilePath, lineno, column + 1);
int iSafetyCnt = 0;
while (true)
{
if (iSafetyCnt > 100)
{
System.Windows.Forms.MessageBox.Show("待ち時間エラー");
break;
}
if (isDataAnalyzed)
{
break;
}
System.Threading.Thread.Sleep(50);
}
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
}
}
public DelegateCommand(CommandDelegate execute, Func <bool> canExecute)
{
_execute = execute;
_canExecute = canExecute;
}
public SignCommand(int coolDown, List <string> permissions, CommandDelegate cmd, params string[] names)
: base(permissions, cmd, names)
{
_cooldown = coolDown;
}
/// <summary>
/// Call this from a region module to add a command to the OpenSim console.
/// </summary>
/// <param name="mod"></param>
/// <param name="command"></param>
/// <param name="shorthelp"></param>
/// <param name="longhelp"></param>
/// <param name="descriptivehelp"></param>
/// <param name="callback"></param>
public void AddCommand(IRegionModuleBase module, string command, string shorthelp, string longhelp, string descriptivehelp, CommandDelegate callback)
{
string moduleName = "";
if (module != null)
{
moduleName = module.Name;
}
AddCommand(moduleName, module, command, shorthelp, longhelp, descriptivehelp, callback);
}
// private List<string> CollectHelp(Dictionary<string, object> dict)
// {
// List<string> result = new List<string>();
//
// foreach (KeyValuePair<string, object> kvp in dict)
// {
// if (kvp.Value is Dictionary<string, Object>)
// {
// result.AddRange(CollectHelp((Dictionary<string, Object>)kvp.Value));
// }
// else
// {
// if (((CommandInfo)kvp.Value).long_help != String.Empty)
// result.Add(((CommandInfo)kvp.Value).help_text+" - "+
// ((CommandInfo)kvp.Value).long_help);
// }
// }
// return result;
// }
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="module"></param>
/// <param name="command"></param>
/// <param name="help"></param>
/// <param name="longhelp"></param>
/// <param name="fn"></param>
public void AddCommand(string module, bool shared, string command,
string help, string longhelp, CommandDelegate fn)
{
AddCommand(module, shared, command, help, longhelp, String.Empty, fn);
}
public Command(string permissionneeded, CommandDelegate cmd, params string[] names)
: this(cmd, names)
{
Permission = permissionneeded;
}
public ConsoleCommand(string command, CommandDelegate action, string help = "")
{
Command = command;
Action = action;
Help = help;
}
public ConsoleCommand(string command, CommandDelegate action, bool elevated, string help = "") : this(command, action, help)
{
Elevated = elevated;
}
public DelegateCommand(string name, CommandDelegate <TClientSession, TPackageInfo> execution)
{
Name = name;
m_Execution = execution;
}
public void AddCommand(string cmd, CommandDelegate deleg)
{
commandDelegates[cmd] = deleg;
}
public Command(string name, CommandDelegate act, object obj)
{
_name = name;
action = act;
MemoryObject = obj;
}
public void AddCommand(string module, bool shared, string command, string help, string longhelp, string descriptivehelp, CommandDelegate fn) {}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="module"></param>
/// <param name="command"></param>
/// <param name="help"></param>
/// <param name="longhelp"></param>
/// <param name="descriptivehelp"></param>
/// <param name="fn"></param>
public void AddCommand(string module, bool shared, string command,
string help, string longhelp, string descriptivehelp,
CommandDelegate fn)
{
string[] parts = Parser.Parse(command);
Dictionary <string, Object> current = tree;
foreach (string part in parts)
{
if (current.ContainsKey(part))
{
if (current[part] is Dictionary <string, Object> )
{
current = (Dictionary <string, Object>)current[part];
}
else
{
return;
}
}
else
{
current[part] = new Dictionary <string, Object>();
current = (Dictionary <string, Object>)current[part];
}
}
CommandInfo info;
if (current.ContainsKey(String.Empty))
{
info = (CommandInfo)current[String.Empty];
if (!info.shared && !info.fn.Contains(fn))
{
info.fn.Add(fn);
}
return;
}
info = new CommandInfo();
info.module = module;
info.shared = shared;
info.help_text = help;
info.long_help = longhelp;
info.descriptive_help = descriptivehelp;
info.fn = new List <CommandDelegate>();
info.fn.Add(fn);
current[String.Empty] = info;
// Now add command to modules dictionary
lock (m_modulesCommands)
{
List <CommandInfo> commands;
if (m_modulesCommands.ContainsKey(module))
{
commands = m_modulesCommands[module];
}
else
{
commands = new List <CommandInfo>();
m_modulesCommands[module] = commands;
}
// m_log.DebugFormat("[COMMAND CONSOLE]: Adding to category {0} command {1}", module, command);
commands.Add(info);
}
}
public void FromXml(XmlElement root, CommandDelegate fn)
{
CommandInfo help = (CommandInfo)((Dictionary<string, object>)tree["help"])[String.Empty];
((Dictionary<string, object>)tree["help"]).Remove(string.Empty);
if (((Dictionary<string, object>)tree["help"]).Count == 0)
tree.Remove("help");
CommandInfo quit = (CommandInfo)((Dictionary<string, object>)tree["quit"])[String.Empty];
((Dictionary<string, object>)tree["quit"]).Remove(string.Empty);
if (((Dictionary<string, object>)tree["quit"]).Count == 0)
tree.Remove("quit");
tree.Clear();
ReadTreeLevel(tree, root, fn);
if (!tree.ContainsKey("help"))
tree["help"] = (object) new Dictionary<string, object>();
((Dictionary<string, object>)tree["help"])[String.Empty] = help;
if (!tree.ContainsKey("quit"))
tree["quit"] = (object) new Dictionary<string, object>();
((Dictionary<string, object>)tree["quit"])[String.Empty] = quit;
}
protected override async Task Decorate(TestCommand command, CancellationToken cancellationToken, CommandDelegate <TestCommand, Unit> continuation) => await continuation.Invoke(command, cancellationToken);
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name = "command">The string that will make the command execute</param>
/// <param name = "commandHelp">The message that will show the user how to use the command</param>
/// <param name = "info">Any information about how the command works or what it does</param>
/// <param name = "fn"></param>
public void AddCommand(string command, string commandHelp, string infomessage, CommandDelegate fn)
{
CommandInfo info = new CommandInfo {
command = command,
commandHelp = commandHelp,
info = infomessage,
fn = new List <CommandDelegate> {
fn
}
};
tree.AddCommand(info);
}
public async Task requires_continuation()
{
continuation = null;
await Assert.ThrowsAsync <ArgumentNullException>(nameof( continuation ), invoke);
}
/// <summary>
/// Call this from a region module to add a command to the OpenSim console.
/// </summary>
/// <param name="mod">
/// The use of IRegionModuleBase is a cheap trick to get a different method signature,
/// though all new modules should be using interfaces descended from IRegionModuleBase anyway.
/// </param>
/// <param name="category">
/// Category of the command. This is the section under which it will appear when the user asks for help
/// </param>
/// <param name="command"></param>
/// <param name="shorthelp"></param>
/// <param name="longhelp"></param>
/// <param name="callback"></param>
public void AddCommand(
string category, IRegionModuleBase module, string command, string shorthelp, string longhelp, CommandDelegate callback)
{
AddCommand(category, module, command, shorthelp, longhelp, string.Empty, callback);
}
public void AddCommand(string module, bool shared, string command, string help, string longhelp, CommandDelegate fn)
{
m_commands.AddCommand(module, shared, command, help, longhelp, fn);
}
public Command(CommandDelegate commandDelegate)
: this()
{
_commandDelegate = commandDelegate;
}
public override bool CanSeeCommand(TSPlayer sender, CommandDelegate <TSPlayer> command)
{
var permissions = command.GetCustomAttribute <CommandPermissions>();
return(permissions == null || permissions.Permissions.Any(perm => sender.Group.HasPermission(perm)));
}
public static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Welcome to LibClassicBot beta.");
Console.WriteLine("Below is a list of commands and how to use them");
Console.WriteLine(".position - Announces the position of the bot in the map.");
Console.WriteLine(".allow <user> - Adds a user to a list of allowed operators.");
Console.WriteLine(".disallow <user> - Removes a user from the list of allowed operators.");
Console.WriteLine(".say <message> - Makes the bot send the specified message.");
Console.WriteLine(".players - Lists the visibile players to the bot in the current map.");
Console.WriteLine(".move <x,y,z> - Moves the bot to the specified coordinates.");
Console.WriteLine(".place <x,y,z> - Attempts to place a block at the specified coordinates.");
Console.WriteLine(".haspaid <username> - Announces if a user has paid or not.");
Console.WriteLine(".cuboid <blocktype> - Cuboids between two points.");
Console.WriteLine(".cuboidh <blocktype> - Draws a hollow cuboid between two points.");
Console.WriteLine(".cuboidw <blocktype> - Draws a wireframe between two points.");
Console.WriteLine(".ellipsoid <blocktype> - Draws an ellipsoid between two points.");
Console.WriteLine(".pyramid <blocktype> - Draws an upwards pyramid between two points.");
Console.WriteLine(".follow <username> - Follows player. (Case sensitive)");
Console.WriteLine(".speed <number> - The number of blocks to place per second.");
Console.WriteLine(".abort - Stops the currently running draw operation.");
Console.WriteLine(".drawimg 0 <filename> - Attempts to draw the specified image.");
Console.ResetColor();
Console.WriteLine("Enter the username to be used by the bot: (Minecraft account)");
string username = Console.ReadLine();
Console.WriteLine("Enter the password to be used by the bot: (Minecraft account)");
string password = Console.ReadLine();
Console.WriteLine("Enter the address of the server to connect to: ");
string hash = Console.ReadLine();
if (!hash.StartsWith("http"))
{
if (hash.StartsWith("minecraft"))
{
hash = "http://" + hash;
}
else
{
hash = "http://minecraft.net/classic/play/" + hash;
}
}
ClassicBot Bot1 = new ClassicBot(username, password, hash);
ConsoleLogger logger = new ConsoleLogger();
Bot1.RegisterLogger(logger);
FileLogger file = new FileLogger();
Bot1.RegisterLogger(file);
Bot1.Events.ChatMessage += Bot1_ChatMessage;
Bot1.Events.PlayerMoved += Bot1_PlayerMoved;
Bot1.Events.RemoteSessionStarted += RemoteSessionStarted;
Bot1.Events.RemoteUserLoggedIn += RemoteUserLoggedIn;
Bot1.Events.RemoteSessionEnded += RemoteSessionEnded;
#if !MONO
Bot1.Events.MapLoaded += Bot1_MapLoaded;
Bot1.Events.ConfigLoading += delegate { Console.WriteLine("Loading"); };
#endif
#region Plugins
CommandDelegate MazeCommand = delegate(string Line)
{
Maze maze = new Maze();
maze.originalchatline = Line;
Bot1.SetDrawer(Line, maze, 2);
};
Bot1.RegisteredCommands.Add("maze", MazeCommand);
CommandDelegate DrawCommand = delegate(string Line)
{
DrawImage img = new DrawImage();
img.originalchatline = Line;
Bot1.SetDrawer(Line, img, 2);
};
Bot1.RegisteredCommands.Add("drawimg", DrawCommand);
CommandDelegate PositionCommand = delegate(string Line)
{
Bot1.SendMessagePacket(String.Format("Positon in world is at {0},{1},{2}.", Bot1.X, Bot1.Y, Bot1.Z));
};
Bot1.RegisteredCommands.Add("position", PositionCommand);
CommandDelegate AddOpCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
Bot1.AddOperator(full[1]);
Bot1.SendMessagePacket("Allowed user: "******"allow", AddOpCommand);
CommandDelegate RemoveOpCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
Bot1.RemoveOperator(full[1]);
Bot1.SendMessagePacket("Disallowed user: "******"disallow", RemoveOpCommand);
CommandDelegate ListOpsCommand = delegate(string Line)
{
string[] names = Bot1.Users.ToArray();
Bot1.SendLongChat(String.Join(", ", names));
};
Bot1.RegisteredCommands.Add("ops", ListOpsCommand);
CommandDelegate SayCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
Bot1.SendMessagePacket(full[1]);
};
Bot1.RegisteredCommands.Add("say", SayCommand);
CommandDelegate PlayersCommand = delegate(string Line)
{
List <string> Names = new List <string>();
foreach (Player player in Bot1.Players.Values)
{
Names.Add(player.Name);
}
string output = String.Join(",", Names.ToArray());
Bot1.SendLongChat("Players in current world: " + output);
};
Bot1.RegisteredCommands.Add("players", PlayersCommand);
CommandDelegate MoveCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
string[] coords = full[1].Split(new char[] { ',' }, 3);
Bot1.SendPositionPacket(Int16.Parse(coords[0]), Int16.Parse(coords[1]), Int16.Parse(coords[2]));
};
Bot1.RegisteredCommands.Add("move", MoveCommand);
CommandDelegate PlaceCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
string[] coords = full[1].Split(new char[] { ',' }, 4);
Bot1.SendBlockPacket(Int16.Parse(coords[0]), Int16.Parse(coords[1]), Int16.Parse(coords[2]), 1, Byte.Parse(coords[3]));
};
Bot1.RegisteredCommands.Add("place", PlaceCommand);
CommandDelegate HasPaidCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
try
{
bool paid;
WebClient client = new WebClient();
string response = client.DownloadString("https://minecraft.net/haspaid.jsp?user="******"minecraft.net returned: " + (int)response.StatusCode + " " + response.StatusCode.ToString());
}
}
else
{
Bot1.SendMessagePacket("Unhandled error occured: " + ex.Status.ToString());
}
}
};
Bot1.RegisteredCommands.Add("haspaid", HasPaidCommand);
CommandDelegate FollowCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
personfollowed = full[1];
Bot1.SendMessagePacket("Following user " + full[1]);
};
Bot1.RegisteredCommands.Add("follow", FollowCommand);
CommandDelegate CuboidCommand = delegate(string Line)
{
Cuboid cuboid = new Cuboid();
Bot1.SetDrawer(Line, cuboid, 2);
};
Bot1.RegisteredCommands.Add("cuboid", CuboidCommand);
CommandDelegate PyramidCommand = delegate(string Line)
{
Pyramid pyramid = new Pyramid();
Bot1.SetDrawer(Line, pyramid, 2);
};
Bot1.RegisteredCommands.Add("pyramid", PyramidCommand);
CommandDelegate AbortCommand = delegate(string Line)
{
Bot1.CancelDrawer();
personfollowed = String.Empty;
};
Bot1.RegisteredCommands.Add("abort", AbortCommand);
CommandDelegate SpeedCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
Bot1.CuboidSleepTime = 1000 / Int32.Parse(full[1]);
};
Bot1.RegisteredCommands.Add("speed", SpeedCommand);
CommandDelegate EllipsoidCommand = delegate(string Line)
{
Ellipsoid ellipsoid = new Ellipsoid();
Bot1.SetDrawer(Line, ellipsoid, 2);
};
Bot1.RegisteredCommands.Add("ellipsoid", EllipsoidCommand);
CommandDelegate CuboidHCommand = delegate(string Line)
{
CuboidHollow cuboidh = new CuboidHollow();
Bot1.SetDrawer(Line, cuboidh, 2);
};
Bot1.RegisteredCommands.Add("cuboidh", CuboidHCommand);
CommandDelegate CuboidWCommand = delegate(string Line)
{
CuboidWireframe cuboidw = new CuboidWireframe();
Bot1.SetDrawer(Line, cuboidw, 2);
};
Bot1.RegisteredCommands.Add("cuboidw", CuboidWCommand);
CommandDelegate LineCommand = delegate(string Line)
{
Line line = new Line();
Bot1.SetDrawer(Line, line, 2);
};
Bot1.RegisteredCommands.Add("line", LineCommand);
CommandDelegate IgnoreCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
Bot1.IgnoredUserList.Add(full[1]);
Bot1.SendMessagePacket("Ignored user: "******"ignore", IgnoreCommand);
CommandDelegate UnIgnoreCommand = delegate(string Line)
{
string[] full = Bot1.GetMessage(Line).Split(new char[] { ' ' }, 2);
Bot1.IgnoredUserList.Remove(full[1]);
Bot1.SendMessagePacket("Unignored user: "******"unignore", UnIgnoreCommand);
/*CommandDelegate TestPosCommand = delegate(string Line)
* { //Ain't no way to stop it. Uncomment with severe caution.
* new System.Threading.Thread(
* delegate() {
* Random rnd = new Random();
* while(true){
*
* int rndval1 = rnd.Next(0, 360);
* byte newpitch = Extensions.DegreesToYaw(rndval1);
* int rndval2 = rnd.Next(0, 360);
* byte newyaw = Extensions.DegreesToYaw(rndval2);
* Bot1.SendPositionPacket(Bot1.X, Bot1.Y, Bot1.Z, newyaw, newpitch);
* System.Threading.Thread.Sleep(10);
* }
* }).Start();
* };
* Bot1.RegisteredCommands.Add("testpos", TestPosCommand);*/
#endregion
StaticBot1 = Bot1;
Bot1.Start(false);
loop:
{
string response = Console.ReadLine();
Bot1.SendMessagePacket(response);
goto loop;
}
}
public Command(string permissions, CommandDelegate cmd, params string[] names)
: this(cmd, names)
{
Permissions = new List<string> { permissions };
}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="command">The string that will make the command execute</param>
/// <param name="commandHelp">The message that will show the user how to use the command</param>
/// <param name="infomessage">Any information about how the command works or what it does</param>
/// <param name="fn"></param>
/// <param name="requiresAScene">Whether this command requires a scene to be fired</param>
/// <param name="fireOnceForAllScenes">Whether this command will only be executed once if there is no current scene</param>
public void AddCommand(string command, string commandHelp, string infomessage, CommandDelegate fn, bool requiresAScene, bool fireOnceForAllScenes)
{
CommandInfo info = new CommandInfo {
command = command,
commandHelp = commandHelp,
info = infomessage,
fireOnceForAllScenes = fireOnceForAllScenes,
requiresAScene = requiresAScene,
fn = new List <CommandDelegate> {
fn
}
};
tree.AddCommand(info);
}
public Command(string cmdname, string permissionneeded, CommandDelegate cmd)
{
Name = cmdname;
permission = permissionneeded;
command = cmd;
}
public async Task InvokeAsync(CommandContext context, CommandDelegate next)
{
context.NotNull(nameof(context));
if (context.Result.HasContent())
{
await next(context);
return;
}
if (context.Command.HasContent())
{
var result = await ExecutePreconditionsForContextAsync(context);
if (result.Success)
{
await next(context);
}
else
{
context.Result = result;
}
return;
}
var matchesFeature = context.Features.Get <ICommandMatchesFeature>();
if (matchesFeature.HasNoContent() || matchesFeature.CommandMatches.HasNoContent())
{
throw new InvalidOperationException($"Can't get command matches from feature: {nameof(ICommandMatchesFeature)}.");
}
var matches = matchesFeature.CommandMatches;
var fails = new Dictionary <ICommand, IResult>();
var bestMatches = new List <ICommandMatch>();
foreach (var match in matches)
{
var command = match.Command;
var result = await ExecutePreconditionsAsync(command, context);
if (result.Success)
{
bestMatches.Add(match);
}
else
{
fails.Add(command, result);
}
}
if (bestMatches.HasNoContent())
{
_logger.LogInformation("All matched commands returned fail for input count.");
context.Result = MiddlewareUtils.GetErrorResult(fails);
return;
}
matchesFeature.CommandMatches = bestMatches;
await next(context);
}
/// <summary>
/// Call this from a region module to add a command to the OpenSim console.
/// </summary>
/// <param name="mod"></param>
/// <param name="command"></param>
/// <param name="shorthelp"></param>
/// <param name="longhelp"></param>
/// <param name="callback"></param>
public void AddCommand(object mod, string command, string shorthelp, string longhelp, CommandDelegate callback)
{
AddCommand(mod, command, shorthelp, longhelp, string.Empty, callback);
}
public Command(List<string> permissions, CommandDelegate cmd, params string[] names)
: this(cmd, names)
{
Permissions = permissions;
}
public Command(string name, T state, CommandDelegate f)
{
this.name = name;
this.state = state;
this.command = f;
}
public CommandMethod(CommandDelegate method, CommandPermission permission = CommandPermission.Normal)
{
Method = method;
Permission = permission;
}
private bool DebugMode = false; //System.Diagnostics.Debugger.IsAttached;
#endregion Fields
#region Methods
/// <summary> Adds a command to the Queue of commands to be executed. </summary>
/// <param name="Command">The anonymous delegate to execute.</param>
/// <param name="Line">The chatline which triggered the execution, used for arguements.</param>
public void EnqueueCommand( CommandDelegate command, string Line )
{
if( !CommandsThreadStarted ) return;
CommandQueue.Enqueue( new InternalCommand( command, Line ) );
}
public void FromXml(XmlElement root, CommandDelegate fn) {}
public GriderProxyFrame(string[] args)
{
//bool externalPlugin = false;
this.args = args;
GriderProxyConfig proxyConfig = new GriderProxyConfig("GridSurferProxy", "Crista Lopes / Diva", args);
proxy = new GriderProxy(proxyConfig);
// add delegates for login
proxy.SetLoginRequestDelegate(new XmlRpcRequestDelegate(LoginRequest));
proxy.SetLoginResponseDelegate(new XmlRpcResponseDelegate(LoginResponse));
// add a delegate for outgoing chat
proxy.AddDelegate(PacketType.ChatFromViewer, Direction.Outgoing, new PacketDelegate(ChatFromViewerOut));
// handle command line arguments
foreach (string arg in args)
if (arg == "--log-login")
logLogin = true;
else if (arg.Substring(0, 2) == "--")
{
int ipos = arg.IndexOf("=");
if (ipos != -1)
{
string sw = arg.Substring(0, ipos);
string val = arg.Substring(ipos + 1);
Console.WriteLine("arg '" + sw + "' val '" + val + "'");
if (sw == "--load")
{
//externalPlugin = true;
LoadPlugin(val);
}
}
}
commandDelegates["/load"] = new CommandDelegate(CmdLoad);
}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="module"></param>
/// <param name="command"></param>
/// <param name="help"></param>
/// <param name="longhelp"></param>
/// <param name="descriptivehelp"></param>
/// <param name="fn"></param>
public void AddCommand(string module, bool shared, string command,
string help, string longhelp, string descriptivehelp,
CommandDelegate fn)
{
string[] parts = Parser.Parse(command);
Dictionary<string, Object> current = tree;
foreach (string part in parts)
{
if (current.ContainsKey(part))
{
if (current[part] is Dictionary<string, Object>)
current = (Dictionary<string, Object>)current[part];
else
return;
}
else
{
current[part] = new Dictionary<string, Object>();
current = (Dictionary<string, Object>)current[part];
}
}
CommandInfo info;
if (current.ContainsKey(String.Empty))
{
info = (CommandInfo)current[String.Empty];
if (!info.shared && !info.fn.Contains(fn))
info.fn.Add(fn);
return;
}
info = new CommandInfo();
info.module = module;
info.shared = shared;
info.help_text = help;
info.long_help = longhelp;
info.descriptive_help = descriptivehelp;
info.fn = new List<CommandDelegate>();
info.fn.Add(fn);
current[String.Empty] = info;
// Now add command to modules dictionary
lock (m_modulesCommands)
{
List<CommandInfo> commands;
if (m_modulesCommands.ContainsKey(module))
{
commands = m_modulesCommands[module];
}
else
{
commands = new List<CommandInfo>();
m_modulesCommands[module] = commands;
}
// m_log.DebugFormat("[COMMAND CONSOLE]: Adding to category {0} command {1}", module, command);
commands.Add(info);
}
}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="module"></param>
/// <param name="command"></param>
/// <param name="help"></param>
/// <param name="longhelp"></param>
/// <param name="fn"></param>
public void AddCommand(string module, bool shared, string command,
string help, string longhelp, CommandDelegate fn)
{
AddCommand(module, shared, command, help, longhelp,
String.Empty, fn);
}
private void ReadTreeLevel(Dictionary<string, object> level, XmlNode node, CommandDelegate fn)
{
Dictionary<string, object> next;
string name;
XmlNodeList nodeL = node.ChildNodes;
XmlNodeList cmdL;
CommandInfo c;
foreach (XmlNode part in nodeL)
{
switch (part.Name)
{
case "Level":
name = ((XmlElement)part).GetAttribute("Name");
next = new Dictionary<string, object>();
level[name] = next;
ReadTreeLevel(next, part, fn);
break;
case "Command":
cmdL = part.ChildNodes;
c = new CommandInfo();
foreach (XmlNode cmdPart in cmdL)
{
switch (cmdPart.Name)
{
case "Module":
c.module = cmdPart.InnerText;
break;
case "Shared":
c.shared = Convert.ToBoolean(cmdPart.InnerText);
break;
case "HelpText":
c.help_text = cmdPart.InnerText;
break;
case "LongHelp":
c.long_help = cmdPart.InnerText;
break;
case "Description":
c.descriptive_help = cmdPart.InnerText;
break;
}
}
c.fn = new List<CommandDelegate>();
c.fn.Add(fn);
level[String.Empty] = c;
break;
}
}
}
public bool Add(string commandName, string commandDescription, string commandFullDescription, CommandDelegate <TResult> onExecuteCommand, params ArgumentString[] arguments) => Add(commandName, commandDescription, commandFullDescription, (executionArguments, context) => ((onExecuteCommand == null) ? DefaultParseReturnValue : onExecuteCommand(executionArguments)), arguments);
internal InternalCommand( CommandDelegate Command, string Line )
{
command = Command;
line = Line;
}
public Command(string name, CommandDelegate f)
{
this.name = name;
this.state = default(T);
this.command = f;
}
public void AddCommand(string cmd, CommandDelegate deleg)
{
commandDelegates[cmd] = deleg;
}
public void AddRule(ParserSequence sequence, CommandDelegate command, string example)
{
AddRule(new CommandParserRule(sequence, command, example));
}
public void AddCommand(string module, bool shared, string command, string help, string longhelp,
CommandDelegate fn)
{
m_commands.AddCommand(module, shared, command, help, longhelp, fn);
}
public void AddRule(ParserSequence sequence, CommandDelegate command)
{
AddRule(new CommandParserRule(sequence, command, null));
}
/// <summary>
/// Add a command to those which can be invoked from the console.
/// </summary>
/// <param name="module"></param>
/// <param name="command"></param>
/// <param name="help"></param>
/// <param name="longhelp"></param>
/// <param name="descriptivehelp"></param>
/// <param name="fn"></param>
public void AddCommand(string module, bool shared, string command,
string help, string longhelp, string descriptivehelp,
CommandDelegate fn)
{
string[] parts = Parser.Parse(command);
Dictionary<string, Object> current = tree;
foreach (string s in parts)
{
if (current.ContainsKey(s))
{
if (current[s] is Dictionary<string, Object>)
{
current = (Dictionary<string, Object>)current[s];
}
else
return;
}
else
{
current[s] = new Dictionary<string, Object>();
current = (Dictionary<string, Object>)current[s];
}
}
CommandInfo info;
if (current.ContainsKey(String.Empty))
{
info = (CommandInfo)current[String.Empty];
if (!info.shared && !info.fn.Contains(fn))
info.fn.Add(fn);
return;
}
info = new CommandInfo();
info.module = module;
info.shared = shared;
info.help_text = help;
info.long_help = longhelp;
info.descriptive_help = descriptivehelp;
info.fn = new List<CommandDelegate>();
info.fn.Add(fn);
current[String.Empty] = info;
}
public bool Add(string commandName, string commandDescription, string commandFullDescription, CommandDelegate <TResult, TContext> onExecuteCommand, params ArgumentString[] arguments)
{
bool ret = false;
Command <TResult, TContext> command = Command <TResult, TContext> .New(commandName, commandDescription, commandFullDescription, onExecuteCommand, arguments);
if (commands.Add(command))
{
commandLookup.Add(command.Name, command);
ret = true;
}
return(ret);
}
