public static bool CheckIronPythonInput(TSPlayer player, string text)
        {
            IronPythonEnvironment pyEnv = player.PyEnv();

            if (text.StartsWith(IronPythonConfig.CommandSpecifier) && pyEnv != null)
            {
                RunIronPython(player, pyEnv, text.Substring(IronPythonConfig.CommandSpecifier.Length));
                return(true);
            }
            return(false);
        }
 public static bool DisposeEnvironment(IronPythonEnvironment pyEnv, TSPlayer player)
 {
     try
     {
         pyEnv.Dispose();
         return(true);
     }
     catch (Exception e)
     {
         PrintError(player, pyEnv, e);
         return(false);
     }
 }
        public static void ResetIronPythonCommand(CommandArgs args)
        {
            if (args.Parameters.Count == 1)
            {
                IronPythonEnvironment py = args.Player.PyEnv();
                if (!DisposeEnvironment(py, args.Player))
                {
                    return;
                }
                if (!InitializeEnvironment(py, args.Player))
                {
                    return;
                }
                args.Player.SendSuccessMessage($"IronPython[{py.Name}] has been reset.");
            }
            else if (args.Parameters.Count == 2)
            {
                if (args.Parameters[1].ToLower() == "all")
                {
                    foreach (var pair in IronPythonConfig.Environments)
                    {
                        if (!DisposeEnvironment(pair.Value, args.Player))
                        {
                            return;
                        }
                        if (!InitializeEnvironment(pair.Value, args.Player))
                        {
                            return;
                        }
                    }
                    args.Player.SendSuccessMessage($"All IronPythons have been reset.");
                    return;
                }

                if (!IronPythonConfig.Environments.ContainsKey(args.Parameters[1]))
                {
                    args.Player.SendErrorMessage("No such environment.");
                    return;
                }
                IronPythonEnvironment py = IronPythonConfig.Environments[args.Parameters[1]];
                if (!DisposeEnvironment(py, args.Player))
                {
                    return;
                }
                if (!InitializeEnvironment(py, args.Player))
                {
                    return;
                }
                args.Player.SendSuccessMessage($"IronPython[{py.Name}] has been reset.");
            }
        }
        public static void RunIronPythonThread(TSPlayer player, IronPythonEnvironment pyEnv, string command)
        {
            try
            {
                pyEnv.RunScript(command, player);
            }
            catch (Exception e)
            {
                PrintError(player, pyEnv, e);
            }

            //if (player.HasPermission(IronPythonConfig.ControlPermission))
            //pyEnv.UpdateHooks();
        }
 public static void PrintError(TSPlayer player, IronPythonEnvironment pyEnv, Exception e)
 {
     try
     {
         if (pyEnv.CallFunctionByName("perror", e) == null)
         {
             //player.SendErrorMessage(e.ToString());
             player.SendErrorMessage(pyEnv.GetExceptionTraceback(e));
         }
     }
     catch (Exception e2)
     {
         player.SendErrorMessage($"Error at perror: {e2}");
         player.SendErrorMessage(e.ToString());
     }
 }
 public static void RunIronPython(TSPlayer player, IronPythonEnvironment pyEnv, string command)
 {
     Task.Run(() => RunIronPythonThread(player, pyEnv, command));
 }