Merge branch 'preview'

.gitignore

@@ -98,7 +98,6 @@ StyleCopReport.xml
 *.pidb
 *.svclog
 *.scc
-*.code-workspace
 
 # Chutzpah Test files
 _Chutzpah*
@@ -363,14 +362,3 @@ MigrationBackup/
 
 # Fody - auto-generated XML schema
 FodyWeavers.xsd
-
-*.txt
-
-#folders
-/Plugins/
-/DiscordBot.rar
-/DiscordBot/Data/
-/DiscordBot/Updater/
-.idea/
-/DiscordBotWeb/
-DiscordBot/Launcher.exe

.vscode/launch.json

@@ -1,26 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            // Use IntelliSense to find out which attributes exist for C# debugging
-            // Use hover for the description of the existing attributes
-            // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
-            "name": ".NET Core Launch (console)",
-            "type": "coreclr",
-            "request": "launch",
-            "preLaunchTask": "build",
-            // If you have changed target frameworks, make sure to update the program path.
-            "program": "${workspaceFolder}/DiscordBot/bin/Debug/net6.0/DiscordBot.dll",
-            "args": [],
-            "cwd": "${workspaceFolder}/DiscordBot/bin/Debug/net6.0/",
-            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
-            "console": "externalTerminal",
-            "stopAtEntry": false
-        },
-        {
-            "name": ".NET Core Attach",
-            "type": "coreclr",
-            "request": "attach"
-        }
-    ]
-}

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "rpc.enabled": true,
+    "discord.enabled": true
+}

.vscode/tasks.json

@@ -1,41 +0,0 @@
-{
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "build",
-            "command": "dotnet",
-            "type": "process",
-            "args": [
-                "build",
-                "${workspaceFolder}/DiscordBot/DiscordBot.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
-            ],
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "publish",
-            "command": "dotnet",
-            "type": "process",
-            "args": [
-                "publish",
-                "${workspaceFolder}/DiscordBot/DiscordBot.csproj",
-                "/property:GenerateFullPaths=true",
-                "/consoleloggerparameters:NoSummary"
-            ],
-            "problemMatcher": "$msCompile"
-        },
-        {
-            "label": "watch",
-            "command": "dotnet",
-            "type": "process",
-            "args": [
-                "watch",
-                "run",
-                "--project",
-                "${workspaceFolder}/DiscordBot/DiscordBot.csproj"
-            ],
-            "problemMatcher": "$msCompile"
-        }
-    ]
-}

BUILDS/net5.0/CMD_LevelingSystem.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v5.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v5.0": {
+      "CMD_LevelingSystem/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "CMD_LevelingSystem.dll": {}
+        }
+      },
+      "Discord.Net/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.5.0",
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Interactions": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Discord.Net.Webhook": "3.5.0"
+        }
+      },
+      "Discord.Net.Commands/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.5.0": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.5.0"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "CMD_LevelingSystem/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IUtexpvogudb1rllKBWkIEpBVQoToMjtVo81KPkt+gNMe7KtRDcZJgcn6+72viMtyw0e95OJPXFV5VEA/n2OQQ==",
+      "path": "discord.net/3.5.0",
+      "hashPath": "discord.net.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ClTv8aiTlitvS48YatRiTLvgE2f2uKgmHNPVBIuvJBHZO2u4bZCzoN1fid+pZn2sbVOkt8uftlLGzz5DSZlFIA==",
+      "path": "discord.net.commands/3.5.0",
+      "hashPath": "discord.net.commands.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-rCzzaznMVQ+bLMxOpYwTyqm9V22kMy6BxlQisSxemHZDe2Jedz3Clp/a0dToACLz+Dlp3u+jYUfCBnTz7L6f4g==",
+      "path": "discord.net.core/3.5.0",
+      "hashPath": "discord.net.core.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wE9+V9DJ7r+1s4euOi4sGPIAt4sD7r+Tk5s9mrlbLCHVQTK4KllAvcrL25bPFI38FuFceREEzFoRlTrekSyB2Q==",
+      "path": "discord.net.interactions/3.5.0",
+      "hashPath": "discord.net.interactions.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BnTdLFuuQsKvCv08VQrD4X1Hw2Xp+MELIRQiDiKfG01IiQlRTN+1gc3LB1zXgn5xBvC0HXjHxwV22GrMD9uKHQ==",
+      "path": "discord.net.rest/3.5.0",
+      "hashPath": "discord.net.rest.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vCIGZS+m88sQDuFmdbUqg+2RIXS/NJWx8ei3MX+ZEYiAvOkDgQfkIlEnU1NKpds6ivTt5GFlv6UzcWubb5VJ1w==",
+      "path": "discord.net.webhook/3.5.0",
+      "hashPath": "discord.net.webhook.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LjBOvcP40vJ+dhOtBDi8haEeblPAKpAIqR04NBzTM1/0RVavJZH89ovfSQIk42ygkiOaDV4E2x0Mmh6DRoIYcw==",
+      "path": "discord.net.websocket/3.5.0",
+      "hashPath": "discord.net.websocket.3.5.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

BUILDS/net5.0/CMD_Utils.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v5.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v5.0": {
+      "CMD_Utils/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "CMD_Utils.dll": {}
+        }
+      },
+      "Discord.Net/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.5.0",
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Interactions": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Discord.Net.Webhook": "3.5.0"
+        }
+      },
+      "Discord.Net.Commands/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.5.0": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.5.0"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "CMD_Utils/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IUtexpvogudb1rllKBWkIEpBVQoToMjtVo81KPkt+gNMe7KtRDcZJgcn6+72viMtyw0e95OJPXFV5VEA/n2OQQ==",
+      "path": "discord.net/3.5.0",
+      "hashPath": "discord.net.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ClTv8aiTlitvS48YatRiTLvgE2f2uKgmHNPVBIuvJBHZO2u4bZCzoN1fid+pZn2sbVOkt8uftlLGzz5DSZlFIA==",
+      "path": "discord.net.commands/3.5.0",
+      "hashPath": "discord.net.commands.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-rCzzaznMVQ+bLMxOpYwTyqm9V22kMy6BxlQisSxemHZDe2Jedz3Clp/a0dToACLz+Dlp3u+jYUfCBnTz7L6f4g==",
+      "path": "discord.net.core/3.5.0",
+      "hashPath": "discord.net.core.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wE9+V9DJ7r+1s4euOi4sGPIAt4sD7r+Tk5s9mrlbLCHVQTK4KllAvcrL25bPFI38FuFceREEzFoRlTrekSyB2Q==",
+      "path": "discord.net.interactions/3.5.0",
+      "hashPath": "discord.net.interactions.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BnTdLFuuQsKvCv08VQrD4X1Hw2Xp+MELIRQiDiKfG01IiQlRTN+1gc3LB1zXgn5xBvC0HXjHxwV22GrMD9uKHQ==",
+      "path": "discord.net.rest/3.5.0",
+      "hashPath": "discord.net.rest.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vCIGZS+m88sQDuFmdbUqg+2RIXS/NJWx8ei3MX+ZEYiAvOkDgQfkIlEnU1NKpds6ivTt5GFlv6UzcWubb5VJ1w==",
+      "path": "discord.net.webhook/3.5.0",
+      "hashPath": "discord.net.webhook.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LjBOvcP40vJ+dhOtBDi8haEeblPAKpAIqR04NBzTM1/0RVavJZH89ovfSQIk42ygkiOaDV4E2x0Mmh6DRoIYcw==",
+      "path": "discord.net.websocket/3.5.0",
+      "hashPath": "discord.net.websocket.3.5.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

BUILDS/net5.0/EVE_LevelingSystem.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v5.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v5.0": {
+      "EVE_LevelingSystem/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "EVE_LevelingSystem.dll": {}
+        }
+      },
+      "Discord.Net/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.5.0",
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Interactions": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Discord.Net.Webhook": "3.5.0"
+        }
+      },
+      "Discord.Net.Commands/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.5.0": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.5.0"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "EVE_LevelingSystem/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IUtexpvogudb1rllKBWkIEpBVQoToMjtVo81KPkt+gNMe7KtRDcZJgcn6+72viMtyw0e95OJPXFV5VEA/n2OQQ==",
+      "path": "discord.net/3.5.0",
+      "hashPath": "discord.net.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ClTv8aiTlitvS48YatRiTLvgE2f2uKgmHNPVBIuvJBHZO2u4bZCzoN1fid+pZn2sbVOkt8uftlLGzz5DSZlFIA==",
+      "path": "discord.net.commands/3.5.0",
+      "hashPath": "discord.net.commands.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-rCzzaznMVQ+bLMxOpYwTyqm9V22kMy6BxlQisSxemHZDe2Jedz3Clp/a0dToACLz+Dlp3u+jYUfCBnTz7L6f4g==",
+      "path": "discord.net.core/3.5.0",
+      "hashPath": "discord.net.core.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wE9+V9DJ7r+1s4euOi4sGPIAt4sD7r+Tk5s9mrlbLCHVQTK4KllAvcrL25bPFI38FuFceREEzFoRlTrekSyB2Q==",
+      "path": "discord.net.interactions/3.5.0",
+      "hashPath": "discord.net.interactions.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BnTdLFuuQsKvCv08VQrD4X1Hw2Xp+MELIRQiDiKfG01IiQlRTN+1gc3LB1zXgn5xBvC0HXjHxwV22GrMD9uKHQ==",
+      "path": "discord.net.rest/3.5.0",
+      "hashPath": "discord.net.rest.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vCIGZS+m88sQDuFmdbUqg+2RIXS/NJWx8ei3MX+ZEYiAvOkDgQfkIlEnU1NKpds6ivTt5GFlv6UzcWubb5VJ1w==",
+      "path": "discord.net.webhook/3.5.0",
+      "hashPath": "discord.net.webhook.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LjBOvcP40vJ+dhOtBDi8haEeblPAKpAIqR04NBzTM1/0RVavJZH89ovfSQIk42ygkiOaDV4E2x0Mmh6DRoIYcw==",
+      "path": "discord.net.websocket/3.5.0",
+      "hashPath": "discord.net.websocket.3.5.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

BUILDS/net5.0/MusicCommands.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v5.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v5.0": {
+      "MusicCommands/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "MusicCommands.dll": {}
+        }
+      },
+      "Discord.Net/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.5.0",
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Interactions": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Discord.Net.Webhook": "3.5.0"
+        }
+      },
+      "Discord.Net.Commands/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.5.0": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.5.0"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "MusicCommands/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IUtexpvogudb1rllKBWkIEpBVQoToMjtVo81KPkt+gNMe7KtRDcZJgcn6+72viMtyw0e95OJPXFV5VEA/n2OQQ==",
+      "path": "discord.net/3.5.0",
+      "hashPath": "discord.net.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ClTv8aiTlitvS48YatRiTLvgE2f2uKgmHNPVBIuvJBHZO2u4bZCzoN1fid+pZn2sbVOkt8uftlLGzz5DSZlFIA==",
+      "path": "discord.net.commands/3.5.0",
+      "hashPath": "discord.net.commands.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-rCzzaznMVQ+bLMxOpYwTyqm9V22kMy6BxlQisSxemHZDe2Jedz3Clp/a0dToACLz+Dlp3u+jYUfCBnTz7L6f4g==",
+      "path": "discord.net.core/3.5.0",
+      "hashPath": "discord.net.core.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wE9+V9DJ7r+1s4euOi4sGPIAt4sD7r+Tk5s9mrlbLCHVQTK4KllAvcrL25bPFI38FuFceREEzFoRlTrekSyB2Q==",
+      "path": "discord.net.interactions/3.5.0",
+      "hashPath": "discord.net.interactions.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BnTdLFuuQsKvCv08VQrD4X1Hw2Xp+MELIRQiDiKfG01IiQlRTN+1gc3LB1zXgn5xBvC0HXjHxwV22GrMD9uKHQ==",
+      "path": "discord.net.rest/3.5.0",
+      "hashPath": "discord.net.rest.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vCIGZS+m88sQDuFmdbUqg+2RIXS/NJWx8ei3MX+ZEYiAvOkDgQfkIlEnU1NKpds6ivTt5GFlv6UzcWubb5VJ1w==",
+      "path": "discord.net.webhook/3.5.0",
+      "hashPath": "discord.net.webhook.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LjBOvcP40vJ+dhOtBDi8haEeblPAKpAIqR04NBzTM1/0RVavJZH89ovfSQIk42ygkiOaDV4E2x0Mmh6DRoIYcw==",
+      "path": "discord.net.websocket/3.5.0",
+      "hashPath": "discord.net.websocket.3.5.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

BUILDS/net5.0/StartupEvents.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v5.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v5.0": {
+      "StartupEvents/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "StartupEvents.dll": {}
+        }
+      },
+      "Discord.Net/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.5.0",
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Interactions": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Discord.Net.Webhook": "3.5.0"
+        }
+      },
+      "Discord.Net.Commands/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.5.0": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0",
+          "Discord.Net.WebSocket": "3.5.0",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.5.0": {
+        "dependencies": {
+          "Discord.Net.Core": "3.5.0",
+          "Discord.Net.Rest": "3.5.0"
+        },
+        "runtime": {
+          "lib/net5.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.5.0.0",
+            "fileVersion": "3.5.0.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.5.0"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "StartupEvents/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-IUtexpvogudb1rllKBWkIEpBVQoToMjtVo81KPkt+gNMe7KtRDcZJgcn6+72viMtyw0e95OJPXFV5VEA/n2OQQ==",
+      "path": "discord.net/3.5.0",
+      "hashPath": "discord.net.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ClTv8aiTlitvS48YatRiTLvgE2f2uKgmHNPVBIuvJBHZO2u4bZCzoN1fid+pZn2sbVOkt8uftlLGzz5DSZlFIA==",
+      "path": "discord.net.commands/3.5.0",
+      "hashPath": "discord.net.commands.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-rCzzaznMVQ+bLMxOpYwTyqm9V22kMy6BxlQisSxemHZDe2Jedz3Clp/a0dToACLz+Dlp3u+jYUfCBnTz7L6f4g==",
+      "path": "discord.net.core/3.5.0",
+      "hashPath": "discord.net.core.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-wE9+V9DJ7r+1s4euOi4sGPIAt4sD7r+Tk5s9mrlbLCHVQTK4KllAvcrL25bPFI38FuFceREEzFoRlTrekSyB2Q==",
+      "path": "discord.net.interactions/3.5.0",
+      "hashPath": "discord.net.interactions.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BnTdLFuuQsKvCv08VQrD4X1Hw2Xp+MELIRQiDiKfG01IiQlRTN+1gc3LB1zXgn5xBvC0HXjHxwV22GrMD9uKHQ==",
+      "path": "discord.net.rest/3.5.0",
+      "hashPath": "discord.net.rest.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-vCIGZS+m88sQDuFmdbUqg+2RIXS/NJWx8ei3MX+ZEYiAvOkDgQfkIlEnU1NKpds6ivTt5GFlv6UzcWubb5VJ1w==",
+      "path": "discord.net.webhook/3.5.0",
+      "hashPath": "discord.net.webhook.3.5.0.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-LjBOvcP40vJ+dhOtBDi8haEeblPAKpAIqR04NBzTM1/0RVavJZH89ovfSQIk42ygkiOaDV4E2x0Mmh6DRoIYcw==",
+      "path": "discord.net.websocket/3.5.0",
+      "hashPath": "discord.net.websocket.3.5.0.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

BUILDS/net6.0/CMD_Utils.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v6.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v6.0": {
+      "CMD_Utils/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "CMD_Utils.dll": {}
+        }
+      },
+      "Discord.Net/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.7.2",
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Interactions": "3.7.2",
+          "Discord.Net.Rest": "3.7.2",
+          "Discord.Net.WebSocket": "3.7.2",
+          "Discord.Net.Webhook": "3.7.2"
+        }
+      },
+      "Discord.Net.Commands/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.7.2": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Rest": "3.7.2",
+          "Discord.Net.WebSocket": "3.7.2",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Rest": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Rest": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.7.2"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "CMD_Utils/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FAiCLGu5rp6+Z10FjKbbJ6LLpKjbMBGpozixkJlz5LZvuncPx8f4AWFAw7pBecKUuAh983qiZ8CZYZcNXsI4qg==",
+      "path": "discord.net/3.7.2",
+      "hashPath": "discord.net.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-aOEGP04X64htsTr7ozKj9qHpmvOfitSw5gfR8Tw9TX0+FdswD2LNL2KfOAIaxRKZmRTm34aXQEJrVq0K8AptmQ==",
+      "path": "discord.net.commands/3.7.2",
+      "hashPath": "discord.net.commands.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-apwswc6LjN4dj3u27SO3Hr56Jzl91wzReahieoD7IQhV+BJQaRxhTRiEEWFTrBzHfeFHEOQ7r6vZnra3zeFhKA==",
+      "path": "discord.net.core/3.7.2",
+      "hashPath": "discord.net.core.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dwGhEdDB0yyo/lGtjwIDVZmsuD52di7lIZWu/sBtvvA05dMgYZq5S6ILdsBXjOyaHeXd+EV4YMlj2VS/rm619w==",
+      "path": "discord.net.interactions/3.7.2",
+      "hashPath": "discord.net.interactions.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dyp8YaMBNJ837EH1KNz2PNGZqc2y71WFd1+pdldF+pLQJ3Gf/+V7685paAR7bQw7yFNyqEBR/QRBCNp+QIQ7Wg==",
+      "path": "discord.net.rest/3.7.2",
+      "hashPath": "discord.net.rest.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-da3i/mTq2y7mfj3xlHH14S4PivHbflJCVr8OUikJtQrxBOxvPkqP7ZYk3Y9S28q0K8qik+TUjCcjL5gELKrh/A==",
+      "path": "discord.net.webhook/3.7.2",
+      "hashPath": "discord.net.webhook.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-pYCd6ET44ADaNiyEw82TaJnR7TKYHfrKCytWFWMPL5faJhoh260avZn3Hwunlf331lEQ0f4K1CujPkQbNuq7kQ==",
+      "path": "discord.net.websocket/3.7.2",
+      "hashPath": "discord.net.websocket.3.7.2.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

BUILDS/net6.0/MusicCommands.deps.json

@@ -0,0 +1,268 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v6.0",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v6.0": {
+      "MusicCommands/1.0.0": {
+        "dependencies": {
+          "PluginManager": "1.0.0"
+        },
+        "runtime": {
+          "MusicCommands.dll": {}
+        }
+      },
+      "Discord.Net/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Commands": "3.7.2",
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Interactions": "3.7.2",
+          "Discord.Net.Rest": "3.7.2",
+          "Discord.Net.WebSocket": "3.7.2",
+          "Discord.Net.Webhook": "3.7.2"
+        }
+      },
+      "Discord.Net.Commands/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Commands.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Core/3.7.2": {
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Interactive.Async": "5.0.0",
+          "System.ValueTuple": "4.5.0"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Core.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Interactions/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Rest": "3.7.2",
+          "Discord.Net.WebSocket": "3.7.2",
+          "Microsoft.Extensions.DependencyInjection.Abstractions": "5.0.0",
+          "System.Collections.Immutable": "5.0.0",
+          "System.Reactive": "5.0.0"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Interactions.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Rest/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Rest.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.Webhook/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Rest": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.Webhook.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Discord.Net.WebSocket/3.7.2": {
+        "dependencies": {
+          "Discord.Net.Core": "3.7.2",
+          "Discord.Net.Rest": "3.7.2"
+        },
+        "runtime": {
+          "lib/net6.0/Discord.Net.WebSocket.dll": {
+            "assemblyVersion": "3.7.2.0",
+            "fileVersion": "3.7.2.0"
+          }
+        }
+      },
+      "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+        "runtime": {
+          "lib/netstandard2.0/Microsoft.Extensions.DependencyInjection.Abstractions.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.20.51904"
+          }
+        }
+      },
+      "Newtonsoft.Json/13.0.1": {
+        "runtime": {
+          "lib/netstandard2.0/Newtonsoft.Json.dll": {
+            "assemblyVersion": "13.0.0.0",
+            "fileVersion": "13.0.1.25517"
+          }
+        }
+      },
+      "System.Collections.Immutable/5.0.0": {},
+      "System.Interactive.Async/5.0.0": {
+        "dependencies": {
+          "System.Linq.Async": "5.0.0"
+        },
+        "runtime": {
+          "lib/netcoreapp3.1/System.Interactive.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Linq.Async/5.0.0": {
+        "runtime": {
+          "lib/netcoreapp3.1/System.Linq.Async.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.Reactive/5.0.0": {
+        "runtime": {
+          "lib/net5.0/System.Reactive.dll": {
+            "assemblyVersion": "5.0.0.0",
+            "fileVersion": "5.0.0.1"
+          }
+        }
+      },
+      "System.ValueTuple/4.5.0": {},
+      "PluginManager/1.0.0": {
+        "dependencies": {
+          "Discord.Net": "3.7.2"
+        },
+        "runtime": {
+          "PluginManager.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "MusicCommands/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    },
+    "Discord.Net/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FAiCLGu5rp6+Z10FjKbbJ6LLpKjbMBGpozixkJlz5LZvuncPx8f4AWFAw7pBecKUuAh983qiZ8CZYZcNXsI4qg==",
+      "path": "discord.net/3.7.2",
+      "hashPath": "discord.net.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Commands/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-aOEGP04X64htsTr7ozKj9qHpmvOfitSw5gfR8Tw9TX0+FdswD2LNL2KfOAIaxRKZmRTm34aXQEJrVq0K8AptmQ==",
+      "path": "discord.net.commands/3.7.2",
+      "hashPath": "discord.net.commands.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Core/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-apwswc6LjN4dj3u27SO3Hr56Jzl91wzReahieoD7IQhV+BJQaRxhTRiEEWFTrBzHfeFHEOQ7r6vZnra3zeFhKA==",
+      "path": "discord.net.core/3.7.2",
+      "hashPath": "discord.net.core.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Interactions/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dwGhEdDB0yyo/lGtjwIDVZmsuD52di7lIZWu/sBtvvA05dMgYZq5S6ILdsBXjOyaHeXd+EV4YMlj2VS/rm619w==",
+      "path": "discord.net.interactions/3.7.2",
+      "hashPath": "discord.net.interactions.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Rest/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-dyp8YaMBNJ837EH1KNz2PNGZqc2y71WFd1+pdldF+pLQJ3Gf/+V7685paAR7bQw7yFNyqEBR/QRBCNp+QIQ7Wg==",
+      "path": "discord.net.rest/3.7.2",
+      "hashPath": "discord.net.rest.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.Webhook/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-da3i/mTq2y7mfj3xlHH14S4PivHbflJCVr8OUikJtQrxBOxvPkqP7ZYk3Y9S28q0K8qik+TUjCcjL5gELKrh/A==",
+      "path": "discord.net.webhook/3.7.2",
+      "hashPath": "discord.net.webhook.3.7.2.nupkg.sha512"
+    },
+    "Discord.Net.WebSocket/3.7.2": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-pYCd6ET44ADaNiyEw82TaJnR7TKYHfrKCytWFWMPL5faJhoh260avZn3Hwunlf331lEQ0f4K1CujPkQbNuq7kQ==",
+      "path": "discord.net.websocket/3.7.2",
+      "hashPath": "discord.net.websocket.3.7.2.nupkg.sha512"
+    },
+    "Microsoft.Extensions.DependencyInjection.Abstractions/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ORj7Zh81gC69TyvmcUm9tSzytcy8AVousi+IVRAI8nLieQjOFryRusSFh7+aLk16FN9pQNqJAiMd7BTKINK0kA==",
+      "path": "microsoft.extensions.dependencyinjection.abstractions/5.0.0",
+      "hashPath": "microsoft.extensions.dependencyinjection.abstractions.5.0.0.nupkg.sha512"
+    },
+    "Newtonsoft.Json/13.0.1": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A==",
+      "path": "newtonsoft.json/13.0.1",
+      "hashPath": "newtonsoft.json.13.0.1.nupkg.sha512"
+    },
+    "System.Collections.Immutable/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-FXkLXiK0sVVewcso0imKQoOxjoPAj42R8HtjjbSjVPAzwDfzoyoznWxgA3c38LDbN9SJux1xXoXYAhz98j7r2g==",
+      "path": "system.collections.immutable/5.0.0",
+      "hashPath": "system.collections.immutable.5.0.0.nupkg.sha512"
+    },
+    "System.Interactive.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-QaqhQVDiULcu4vm6o89+iP329HcK44cETHOYgy/jfEjtzeFy0ZxmuM7nel9ocjnKxEM4yh1mli7hgh8Q9o+/Iw==",
+      "path": "system.interactive.async/5.0.0",
+      "hashPath": "system.interactive.async.5.0.0.nupkg.sha512"
+    },
+    "System.Linq.Async/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-cPtIuuH8TIjVHSi2ewwReWGW1PfChPE0LxPIDlfwVcLuTM9GANFTXiMB7k3aC4sk3f0cQU25LNKzx+jZMxijqw==",
+      "path": "system.linq.async/5.0.0",
+      "hashPath": "system.linq.async.5.0.0.nupkg.sha512"
+    },
+    "System.Reactive/5.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-erBZjkQHWL9jpasCE/0qKAryzVBJFxGHVBAvgRN1bzM0q2s1S4oYREEEL0Vb+1kA/6BKb5FjUZMp5VXmy+gzkQ==",
+      "path": "system.reactive/5.0.0",
+      "hashPath": "system.reactive.5.0.0.nupkg.sha512"
+    },
+    "System.ValueTuple/4.5.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-okurQJO6NRE/apDIP23ajJ0hpiNmJ+f0BwOlB/cSqTLQlw5upkf+5+96+iG2Jw40G1fCVCyPz/FhIABUjMR+RQ==",
+      "path": "system.valuetuple/4.5.0",
+      "hashPath": "system.valuetuple.4.5.0.nupkg.sha512"
+    },
+    "PluginManager/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

CMD_LevelingSystem/CMD_LevelingSystem.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <BaseOutputPath>..\DiscordBot\bin\Debug\net6.0\Data\Plugins\Commands\LevelingSystem</BaseOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PluginManager\PluginManager.csproj" />
+  </ItemGroup>
+
+</Project>

CMD_LevelingSystem/Level.cs

@@ -0,0 +1,48 @@
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager;
+using PluginManager.Interfaces;
+using PluginManager.Others;
+
+namespace CMD_LevelingSystem;
+
+internal class Level : DBCommand
+{
+    public string Command => "level";
+
+    public string Description => "Display tour current level";
+
+    public string Usage => "level";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        if (!File.Exists(Config.GetValue<string>("LevelingSystemPath") + $"/{message.Author.Id}.dat"))
+        {
+            await context.Channel.SendMessageAsync("You are now unranked !");
+            return;
+        }
+
+        var user = await Functions.ConvertFromJson<User>(Config.GetValue<string>("LevelingSystemPath") + $"/{message.Author.Id}.dat");
+        if (user == null)
+        {
+            await context.Channel.SendMessageAsync("You are now unranked !");
+            return;
+        }
+
+        var builder = new EmbedBuilder();
+        var r       = new Random();
+        builder.WithColor(r.Next(256), r.Next(256), r.Next(256));
+        builder.AddField("Current Level", user.CurrentLevel, true)
+               .AddField("Current EXP", user.CurrentEXP, true)
+               .AddField("Required Exp", user.RequiredEXPToLevelUp, true);
+        builder.WithTimestamp(DateTimeOffset.Now);
+        await context.Channel.SendMessageAsync(embed: builder.Build());
+    }
+}

CMD_LevelingSystem/User.cs

@@ -0,0 +1,18 @@
+using Discord.WebSocket;
+
+namespace CMD_LevelingSystem;
+
+public class DiscordUser
+{
+    public string Username   { get; set; }
+    public ushort DiscordTag { get; set; }
+    public ulong  userID     { get; set; }
+}
+
+public class User
+{
+    public DiscordUser user                 { get; set; }
+    public int         CurrentLevel         { get; set; }
+    public long        CurrentEXP           { get; set; }
+    public long        RequiredEXPToLevelUp { get; set; }
+}

CMD_Utils/CMD_Utils.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <BaseOutputPath></BaseOutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <OutputPath>..\BUILDS\</OutputPath>
+    <ErrorReport>prompt</ErrorReport>
+    <DebugType>none</DebugType>
+    <DebugSymbols>false</DebugSymbols>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PluginManager\PluginManager.csproj" />
+  </ItemGroup>
+
+</Project>

CMD_Utils/Echo.cs

@@ -0,0 +1,23 @@
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+internal class Echo : DBCommand
+{
+    public string Command => "echo";
+
+    public string Description => "Replay with the same message";
+
+    public string Usage => "echo [message]";
+
+    public bool canUseDM     => true;
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        var m = message.Content.Substring(6);
+        await message.Channel.SendMessageAsync(m);
+    }
+}

CMD_Utils/FlipCoin.cs

@@ -0,0 +1,30 @@
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+namespace CMD_Utils;
+
+internal class FlipCoin : DBCommand
+{
+    public string Command => "flip";
+
+    public string Description => "Flip a coin";
+
+    public string Usage => "flip";
+
+    public bool canUseDM => true;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        var random = new System.Random();
+        var r      = random.Next(1, 3);
+        if (r == 1)
+            await message.Channel.SendMessageAsync("Heads");
+        else
+            await message.Channel.SendMessageAsync("Tails");
+    }
+}

CMD_Utils/Poll.cs

@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+using PluginManager.Others;
+
+namespace CMD_Utils;
+
+public class Poll : DBCommand
+{
+    public string Command => "poll";
+
+    public string Description => "Create a poll with options";
+
+    public string Usage => "poll [This-is-question] [This-is-answer-1] [This-is-answer-2] ... ";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => true;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        if (isDM) return;
+        var question     = message.Content.Split(' ')[1].Replace('-', ' ');
+        var answers      = Functions.MergeStrings(message.Content.Split(' '), 2).Split(' ');
+        var embedBuilder = new EmbedBuilder();
+        embedBuilder.Title = question;
+        var len = answers.Length;
+        for (var i = 0; i < len; i++) embedBuilder.AddField($"Answer {i + 1}", answers[i].Replace('-', ' '), true);
+        var msg = await context.Channel.SendMessageAsync(embed: embedBuilder.Build());
+
+        var emotes = new List<IEmote>();
+        emotes.Add(Emoji.Parse(":one:"));
+        emotes.Add(Emoji.Parse(":two:"));
+        emotes.Add(Emoji.Parse(":three:"));
+        emotes.Add(Emoji.Parse(":four:"));
+        emotes.Add(Emoji.Parse(":five:"));
+        emotes.Add(Emoji.Parse(":six:"));
+
+        for (var i = 0; i < len; i++) await msg.AddReactionAsync(emotes[i]);
+    }
+}

CMD_Utils/Random.cs

@@ -0,0 +1,39 @@
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+public class Random : DBCommand
+{
+    public string Command => "random";
+
+    public string Description => "random number between number1 and number2";
+
+    public string Usage => "random [number1] [number2]";
+
+    public bool canUseDM     => true;
+    public bool canUseServer => true;
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        try
+        {
+            var msg = message.Content;
+            var a   = int.Parse(msg.Split(' ')[1]);
+            var b   = int.Parse(msg.Split(' ')[2]);
+
+            if (a > b)
+            {
+                var temp = a;
+                a        = b;
+                b        = temp;
+            }
+
+            await message.Channel.SendMessageAsync("Your random generated number is " + new System.Random().Next(a, b));
+        }
+        catch
+        {
+            await message.Channel.SendMessageAsync("Invalid numbers or no numbers:\nUsage: " + Usage);
+        }
+    }
+}

DiscordBot/App.config

@@ -0,0 +1,4 @@
+<dependentAssembly>
+	<assemblyIdentity name="System.Runtime" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+	<bindingRedirect oldVersion="0.0.0.0-5.0.0.0" newVersion="4.0.0.0" />
+</dependentAssembly>

DiscordBot/Discord/Commands/Help.cs

@@ -1,8 +1,6 @@
-using System.Collections.Generic;
+using Discord;
-
+using Discord.Commands;
-using Discord;
+using Discord.WebSocket;
-
-using PluginManager;
 using PluginManager.Interfaces;
 using PluginManager.Loaders;
 using PluginManager.Others;
@@ -19,17 +17,25 @@ internal class Help : DBCommand
     /// </summary>
     public string Command => "help";
 
-    public List<string> Aliases => null;
-
     /// <summary>
     ///     Command Description
     /// </summary>
-    public string Description => "This command allows you to check all loaded commands";
+    public string Description => "This command allows you to check all loadded commands";
 
     /// <summary>
     ///     Command usage
     /// </summary>
-    public string Usage => "help <command>";
+    public string Usage => "help";
+
+    /// <summary>
+    ///     Check if the command can be used <inheritdoca DM <see cref="IChannel" />/>
+    /// </summary>
+    public bool canUseDM => true;
+
+    /// <summary>
+    ///     Check if the command can be used in a server
+    /// </summary>
+    public bool canUseServer => true;
 
     /// <summary>
     ///     Check if the command require administrator to be executed
@@ -40,52 +46,55 @@ internal class Help : DBCommand
     ///     The main body of the command
     /// </summary>
     /// <param name="context">The command context</param>
-    public void ExecuteServer(DBCommandExecutingArguments args)
+    /// <param name="message">The command message</param>
+    /// <param name="client">The discord bot client</param>
+    /// <param name="isDM">True if the message was sent from a DM channel, false otherwise</param>
+    public void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
     {
-        if (args.arguments is not null)
+        var args = Functions.GetArguments(message);
+        if (args.Count != 0)
         {
-            var e = GenerateHelpCommand(args.arguments[0]);
+            foreach (var item in args)
-            if (e is null)
+            {
-                args.context.Channel.SendMessageAsync("Unknown Command " + args.arguments[0]);
+                var e = GenerateHelpCommand(item);
-            else
+                if (e != null)
-                args.context.Channel.SendMessageAsync(embed: e.Build());
+                    context.Channel.SendMessageAsync(embed: e.Build());
-
+                else
+                    context.Channel.SendMessageAsync("Unknown Command " + item);
+            }
 
             return;
         }
 
         var embedBuilder = new EmbedBuilder();
 
-        var adminCommands = "";
+        var adminCommands  = "";
         var normalCommands = "";
+        var DMCommands     = "";
 
-        foreach (var cmd in PluginLoader.Commands)
+        foreach (var cmd in PluginLoader.Commands!)
+        {
+            if (cmd.canUseDM) DMCommands += cmd.Command + " ";
             if (cmd.requireAdmin)
-                adminCommands += cmd.Command + " ";
+                adminCommands                         += cmd.Command + " ";
-            else
+            else if (cmd.canUseServer) normalCommands += cmd.Command + " ";
-                normalCommands += cmd.Command + " ";
+        }
 
-
+        embedBuilder.AddField("Admin Commands", adminCommands);
-        if (adminCommands.Length > 0)
+        embedBuilder.AddField("Normal Commands", normalCommands);
-            embedBuilder.AddField("Admin Commands", adminCommands);
+        embedBuilder.AddField("DM Commands", DMCommands);
-        if (normalCommands.Length > 0)
+        context.Channel.SendMessageAsync(embed: embedBuilder.Build());
-            embedBuilder.AddField("Normal Commands", normalCommands);
-        args.context.Channel.SendMessageAsync(embed: embedBuilder.Build());
     }
 
     private EmbedBuilder GenerateHelpCommand(string command)
     {
         var embedBuilder = new EmbedBuilder();
-        var cmd = PluginLoader.Commands.Find(p => p.Command == command ||
+        var cmd          = PluginLoader.Commands.Find(p => p.Command == command);
-                                                   (p.Aliases is not null && p.Aliases.Contains(command)));
         if (cmd == null) return null;
 
-        embedBuilder.AddField("Usage", Config.Data["prefix"] + cmd.Usage);
+        embedBuilder.AddField("Usage", cmd.Usage);
         embedBuilder.AddField("Description", cmd.Description);
-        if (cmd.Aliases is null)
-            return embedBuilder;
-        embedBuilder.AddField("Alias", cmd.Aliases.Count == 0 ? "-" : string.Join(", ", cmd.Aliases));
 
         return embedBuilder;
     }
-}
+}

DiscordBot/Discord/Commands/Restart.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Diagnostics;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+using PluginManager.Others;
+using PluginManager.Others.Permissions;
+using DiscordLibCommands = Discord.Commands;
+using DiscordLib = Discord;
+using OperatingSystem = PluginManager.Others.OperatingSystem;
+
+namespace DiscordBot.Discord.Commands;
+
+internal class Restart : DBCommand
+{
+    /// <summary>
+    ///     Command name
+    /// </summary>
+    public string Command => "restart";
+
+    /// <summary>
+    ///     Command Description
+    /// </summary>
+    public string Description => "Restart the bot";
+
+    /// <summary>
+    ///     Command usage
+    /// </summary>
+    public string Usage => "restart [-p | -c | -args | -cmd] <args>";
+
+    /// <summary>
+    ///     Check if the command can be used <inheritdoca DM <see cref="IChannel" />/>
+    /// </summary>
+    public bool canUseDM => false;
+
+    /// <summary>
+    ///     Check if the command can be used in a server
+    /// </summary>
+    public bool canUseServer => true;
+
+    /// <summary>
+    ///     Check if the command require administrator to be executed
+    /// </summary>
+    public bool requireAdmin => false;
+
+    /// <summary>
+    ///     The main body of the command
+    /// </summary>
+    /// <param name="context">The command context</param>
+    /// <param name="message">The command message</param>
+    /// <param name="client">The discord bot client</param>
+    /// <param name="isDM">True if the message was sent from a DM channel, false otherwise</param>
+    public async void Execute(DiscordLibCommands.SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        if (!(message.Author as SocketGuildUser).hasPermission(DiscordLib.GuildPermission.Administrator)) return;
+        var args = Functions.GetArguments(message);
+        var OS   = Functions.GetOperatingSystem();
+        if (args.Count == 0)
+        {
+            switch (OS)
+            {
+                case OperatingSystem.WINDOWS:
+                    Process.Start("./DiscordBot.exe");
+                    break;
+                case OperatingSystem.LINUX:
+                case OperatingSystem.MAC_OS:
+                    Process.Start("./DiscordBot");
+                    break;
+                default:
+                    return;
+            }
+
+            return;
+        }
+
+        switch (args[0])
+        {
+            case "-p":
+            case "-poweroff":
+            case "-c":
+            case "-close":
+                Environment.Exit(0);
+                break;
+            case "-cmd":
+            case "-args":
+                var cmd = "--args";
+
+                if (args.Count > 1)
+                    for (var i = 1; i < args.Count; i++)
+                        cmd += $" {args[i]}";
+
+
+                switch (OS)
+                {
+                    case OperatingSystem.WINDOWS:
+                        Functions.WriteLogFile("Restarting the bot with the following arguments: \"" + cmd + "\"");
+                        Process.Start("./DiscordBot.exe", cmd);
+                        break;
+                    case OperatingSystem.LINUX:
+                        //case PluginManager.Others.OperatingSystem.MAC_OS: ?? - not tested
+                        Process.Start("./DiscordBot", cmd);
+                        break;
+                    default:
+                        return;
+                }
+
+                Environment.Exit(0);
+                break;
+            default:
+                await context.Channel.SendMessageAsync("Invalid argument. Use `help restart` to see the usage.");
+                break;
+        }
+    }
+}

DiscordBot/Discord/Commands/Settings.cs

@@ -0,0 +1,97 @@
+using System;
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager;
+using PluginManager.Interfaces;
+
+namespace DiscordBot.Discord.Commands;
+
+internal class Settings : DBCommand
+{
+    /// <summary>
+    ///     Command name
+    /// </summary>
+    public string Command => "set";
+
+    /// <summary>
+    ///     Command Description
+    /// </summary>
+    public string Description => "This command allows you change all settings. Use \"set help\" to show details";
+
+    /// <summary>
+    ///     Command usage
+    /// </summary>
+    public string Usage => "set [keyword] [new Value]";
+
+    /// <summary>
+    ///     Check if the command can be used <inheritdoca DM <see cref="IChannel" />/>
+    /// </summary>
+    public bool canUseDM => true;
+
+    /// <summary>
+    ///     Check if the command can be used in a server
+    /// </summary>
+    public bool canUseServer => true;
+
+    /// <summary>
+    ///     Check if the command require administrator to be executed
+    /// </summary>
+    public bool requireAdmin => true;
+
+    /// <summary>
+    ///     The main body of the command
+    /// </summary>
+    /// <param name="context">The command context</param>
+    /// <param name="message">The command message</param>
+    /// <param name="client">The discord bot client</param>
+    /// <param name="isDM">True if the message was sent from a DM channel, false otherwise</param>
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        var channel = message.Channel;
+        try
+        {
+            var content = message.Content;
+            var data    = content.Split(' ');
+            var keyword = data[1];
+            if (keyword.ToLower() == "help")
+            {
+                await channel.SendMessageAsync("set token [new value] -- set the value of the new token (require restart)");
+                await channel.SendMessageAsync("set prefix [new value] -- set the value of the new preifx (require restart)");
+
+                return;
+            }
+
+            switch (keyword.ToLower())
+            {
+                case "token":
+                    if (data.Length != 3)
+                    {
+                        await channel.SendMessageAsync("Invalid token !");
+                        return;
+                    }
+
+                    Config.SetValue("token", data[2]);
+                    break;
+                case "prefix":
+                    if (data.Length != 3)
+                    {
+                        await channel.SendMessageAsync("Invalid token !");
+                        return;
+                    }
+
+                    Config.SetValue("token", data[2]);
+                    break;
+                default:
+                    return;
+            }
+
+            await channel.SendMessageAsync("Restart required ...");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.Message);
+            await channel.SendMessageAsync("Unknown usage to this command !\nUsage: " + Usage);
+        }
+    }
+}

DiscordBot/Discord/Core/Boot.cs

@@ -1,14 +1,15 @@
-using System.Net.Mime;
+using System;
-using System;
+using System.Threading;
 using System.Threading.Tasks;
-
 using Discord;
 using Discord.Commands;
 using Discord.WebSocket;
+using PluginManager;
+using static PluginManager.Others.Functions;
 
-namespace PluginManager.Bot;
+namespace DiscordBot.Discord.Core;
 
-public class Boot
+internal class Boot
 {
     /// <summary>
     ///     The bot prefix
@@ -43,7 +44,7 @@ public class Boot
     public Boot(string botToken, string botPrefix)
     {
         this.botPrefix = botPrefix;
-        this.botToken = botToken;
+        this.botToken  = botToken;
     }
 
 
@@ -56,37 +57,20 @@ public class Boot
     /// <summary>
     ///     The start method for the bot. This method is used to load the bot
     /// </summary>
-    /// <param name="config">The discord socket config. If null then the default one will be applied (AlwaysDownloadUsers=true, UseInteractionSnowflakeDate=false, GatewayIntents=GatewayIntents.All)</param>
     /// <returns>Task</returns>
-    public async Task Awake(DiscordSocketConfig? config = null)
+    public async Task Awake()
     {
-        if (config is null)
+        client  = new DiscordSocketClient();
-            config = new DiscordSocketConfig
-            {
-
-                AlwaysDownloadUsers = true,
-
-                //Disable system clock checkup (for responses at slash commands)
-                UseInteractionSnowflakeDate = false,
-
-                GatewayIntents = GatewayIntents.All
-            };
-
-        client = new DiscordSocketClient(config);
         service = new CommandService();
 
         CommonTasks();
 
         await client.LoginAsync(TokenType.Bot, botToken);
-
         await client.StartAsync();
 
         commandServiceHandler = new CommandHandler(client, service, botPrefix);
-
         await commandServiceHandler.InstallCommandsAsync();
 
-
-
         await Task.Delay(2000);
         while (!isReady) ;
     }
@@ -95,38 +79,42 @@ public class Boot
     {
         if (client == null) return;
         client.LoggedOut += Client_LoggedOut;
-        client.Log += Log;
+        client.Log       += Log;
-        client.LoggedIn += LoggedIn;
+        client.LoggedIn  += LoggedIn;
-        client.Ready += Ready;
+        client.Ready     += Ready;
-        client.Disconnected += Client_Disconnected;
     }
 
-    private async Task Client_Disconnected(Exception arg)
+    private Task Client_LoggedOut()
     {
-        if (arg.Message.Contains("401"))
+        WriteLogFile("Successfully Logged Out");
-        {
+        Log(new LogMessage(LogSeverity.Info, "Boot", "Successfully logged out from discord !"));
-            Config.Data.Remove("token");
+        return Task.CompletedTask;
-            Config.Logger.Log("The token is invalid. Please restart the bot and enter a valid token.", this, Others.LogLevel.ERROR);
-            await Task.Delay(4000);
-            Environment.Exit(0);
-        }
-    }
-
-    private async Task Client_LoggedOut()
-    {
-        Config.Logger.Log("Successfully Logged Out", this);
-        await Log(new LogMessage(LogSeverity.Info, "Boot", "Successfully logged out from discord !"));
     }
 
     private Task Ready()
     {
-        isReady = true;
+        Console.Title = "ONLINE";
+        isReady       = true;
+
+        new Thread(() =>
+            {
+                while (true)
+                {
+                    Config.SaveConfig();
+                    Thread.Sleep(10000);
+                }
+            }
+        ).Start();
+
         return Task.CompletedTask;
     }
 
     private Task LoggedIn()
     {
-        Config.Logger.Log("Successfully Logged In", this);
+        Console.Title = "CONNECTED";
+        WriteLogFile("The bot has been logged in at " + DateTime.Now.ToShortDateString() + " (" +
+                     DateTime.Now.ToShortTimeString() + ")"
+        );
         return Task.CompletedTask;
     }
 
@@ -136,13 +124,21 @@ public class Boot
         {
             case LogSeverity.Error:
             case LogSeverity.Critical:
-                Config.Logger.Log(message.Message, this, Others.LogLevel.ERROR);
+                WriteErrFile(message.Message);
+
+                Console.ForegroundColor = ConsoleColor.Red;
+                Console.WriteLine("[ERROR] " + message.Message);
+                Console.ForegroundColor = ConsoleColor.White;
 
                 break;
 
             case LogSeverity.Info:
             case LogSeverity.Debug:
-                Config.Logger.Log(message.Message, this);
+                WriteLogFile(message.Message);
+
+                Console.ForegroundColor = ConsoleColor.Cyan;
+                Console.WriteLine("[INFO] " + message.Message);
+                Console.ForegroundColor = ConsoleColor.White;
 
 
                 break;
@@ -150,4 +146,4 @@ public class Boot
 
         return Task.CompletedTask;
     }
-}
+}

DiscordBot/Discord/Core/CommandHandler.cs

@@ -0,0 +1,131 @@
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Loaders;
+using PluginManager.Others;
+using PluginManager.Others.Permissions;
+
+namespace DiscordBot.Discord.Core;
+
+internal class CommandHandler
+{
+    private readonly string              botPrefix;
+    private readonly DiscordSocketClient client;
+    private readonly CommandService      commandService;
+
+    /// <summary>
+    ///     Command handler constructor
+    /// </summary>
+    /// <param name="client">The discord bot client</param>
+    /// <param name="commandService">The discord bot command service</param>
+    /// <param name="botPrefix">The prefix to watch for</param>
+    public CommandHandler(DiscordSocketClient client, CommandService commandService, string botPrefix)
+    {
+        this.client         = client;
+        this.commandService = commandService;
+        this.botPrefix      = botPrefix;
+    }
+
+    /// <summary>
+    ///     The method to initialize all commands
+    /// </summary>
+    /// <returns></returns>
+    public async Task InstallCommandsAsync()
+    {
+        client.MessageReceived += MessageHandler;
+        await commandService.AddModulesAsync(Assembly.GetEntryAssembly(), null);
+    }
+
+    /// <summary>
+    ///     The message handler for the bot
+    /// </summary>
+    /// <param name="Message">The message got from the user in discord chat</param>
+    /// <returns></returns>
+    private async Task MessageHandler(SocketMessage Message)
+    {
+        try
+        {
+            if (Message as SocketUserMessage == null) return;
+
+            var message = Message as SocketUserMessage;
+
+            if (message == null) return;
+
+            if (!message.Content.StartsWith(botPrefix)) return;
+
+            var argPos = 0;
+
+            if (message.HasMentionPrefix(client.CurrentUser, ref argPos))
+            {
+                await message.Channel.SendMessageAsync("Can not exec mentioned commands !");
+                return;
+            }
+
+            if (message.Author.IsBot) return;
+
+            var context = new SocketCommandContext(client, message);
+
+            await commandService.ExecuteAsync(
+                context,
+                argPos,
+                null
+            );
+
+            var plugin = PluginLoader.Commands!.Where(p => p.Command == message.Content.Split(' ')[0].Substring(botPrefix.Length)).FirstOrDefault();
+
+
+            if (plugin != null)
+            {
+                if (message.Channel == await message.Author.CreateDMChannelAsync())
+                {
+                    if (plugin.canUseDM)
+                    {
+                        if (plugin.requireAdmin)
+                        {
+                            if (message.Author.isAdmin())
+                            {
+                                plugin.Execute(context, message, client, true);
+                                Functions.WriteLogFile($"[{message.Author.Id}] Executed command (DM) : " + plugin.Command);
+                                return;
+                            }
+
+                            await message.Channel.SendMessageAsync("This command is for administrators only !");
+                            return;
+                        }
+
+                        plugin.Execute(context, message, client, true);
+                        Functions.WriteLogFile($"[{message.Author.Id}] Executed command (DM) : " + plugin.Command);
+                        return;
+                    }
+
+                    await message.Channel.SendMessageAsync("This command is not for DMs");
+                    return;
+                }
+
+                if (plugin.canUseServer)
+                {
+                    if (plugin.requireAdmin)
+                    {
+                        if (message.Author.isAdmin())
+                        {
+                            plugin.Execute(context, message, client, false);
+                            Functions.WriteLogFile($"[{message.Author.Id}] Executed command : " + plugin.Command);
+                            return;
+                        }
+
+                        await message.Channel.SendMessageAsync("This command is for administrators only !");
+                        return;
+                    }
+
+                    plugin.Execute(context, message, client, false);
+                    Functions.WriteLogFile($"[{message.Author.Id}] Executed command : " + plugin.Command);
+                }
+            }
+        }
+        catch
+        {
+        }
+    }
+}

DiscordBot/DiscordBot.csproj

@@ -1,39 +1,48 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
+
-    <OutputType>Exe</OutputType>
+	<PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+		<OutputType>Exe</OutputType>
-    <Nullable>disable</Nullable>
+		<TargetFramework>net6.0</TargetFramework>
-    <ApplicationIcon />
+		<Nullable>disable</Nullable>
-    <StartupObject />
+		<ApplicationIcon />
-    <SignAssembly>False</SignAssembly>
+		<StartupObject />
-    <IsPublishable>True</IsPublishable>
+		<SignAssembly>False</SignAssembly>
-    <AssemblyVersion>1.0.2.1</AssemblyVersion>
+		<IsPublishable>True</IsPublishable>
-  </PropertyGroup>
+		<AssemblyVersion>1.0.0.1</AssemblyVersion>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+	</PropertyGroup>
-    <DebugType>none</DebugType>
+
-  </PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+	  <DebugType>none</DebugType>
-    <DebugType>none</DebugType>
+	</PropertyGroup>
-  </PropertyGroup>
+
-  <ItemGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <Compile Remove="Data\**" />
+	  <DebugType>none</DebugType>
-    <Compile Remove="obj\**" />
+	</PropertyGroup>
-    <Compile Remove="Output\**" />
+
-  </ItemGroup>
+	<ItemGroup>
-  <ItemGroup>
+		<Compile Remove="Data\**" />
-    <EmbeddedResource Remove="Data\**" />
+		<Compile Remove="obj\**" />
-    <EmbeddedResource Remove="obj\**" />
+		<Compile Remove="Output\**" />
-    <EmbeddedResource Remove="Output\**" />
+	</ItemGroup>
-  </ItemGroup>
+
-  <ItemGroup>
+	<ItemGroup>
-    <None Remove="Data\**" />
+		<EmbeddedResource Remove="Data\**" />
-    <None Remove="obj\**" />
+		<EmbeddedResource Remove="obj\**" />
-    <None Remove="Output\**" />
+		<EmbeddedResource Remove="Output\**" />
-  </ItemGroup>
+	</ItemGroup>
-  <ItemGroup>
+
-    <PackageReference Include="Discord.Net" Version="3.9.0" />
+	<ItemGroup>
-  </ItemGroup>
+		<None Remove="Data\**" />
-  <ItemGroup>
+		<None Remove="obj\**" />
-    <ProjectReference Include="..\PluginManager\PluginManager.csproj" />
+		<None Remove="Output\**" />
-  </ItemGroup>
+	</ItemGroup>
-</Project>
+
+	<ItemGroup>
+		<PackageReference Include="Discord.Net" Version="3.7.2" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\PluginManager\PluginManager.csproj" />
+	</ItemGroup>
+
+</Project>

DiscordBot/Entry.cs

@@ -1,31 +0,0 @@
-using PluginManager.Others;
-using System;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
-
-namespace DiscordBot
-{
-
-    public class Entry
-    {
-        public static void Main(string[] args)
-        {
-            AppDomain currentDomain = AppDomain.CurrentDomain;
-            currentDomain.AssemblyResolve += new ResolveEventHandler(LoadFromSameFolder);
-
-            static Assembly LoadFromSameFolder(object sender, ResolveEventArgs args)
-            {
-                string folderPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "./Libraries");
-                string assemblyPath = Path.Combine(folderPath, new AssemblyName(args.Name).Name + ".dll");
-                if (!File.Exists(assemblyPath)) return null;
-                Assembly assembly = Assembly.LoadFrom(assemblyPath);
-                return assembly;
-            }
-
-            Program.Startup(args);
-
-        }
-    }
-}

DiscordBot/Installer.cs

@@ -1,117 +0,0 @@
-using System.Diagnostics;
-using System.IO;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using PluginManager;
-using PluginManager.Others;
-using PluginManager.Online;
-
-namespace DiscordBot
-{
-    public static class Installer
-    {
-
-        public static void GenerateStartupConfig()
-        {
-            Console.WriteLine("Welcome to the SethBot installer !");
-            Console.WriteLine("First, we need to configure the bot. Don't worry, it will be quick !");
-            Console.WriteLine("The following information will be stored in the config.json file in the ./Data/Resources folder. You can change it later from there.");
-            Console.WriteLine("The bot tokn is required to run the bot. You can get it from the Discord Developer Portal. (https://discord.com/developers/applications)");
-            Console.WriteLine("Please enter the bot token :");
-            var token = Console.ReadLine();
-
-            Console.WriteLine("Please enter the bot prefix :");
-            var prefix = Console.ReadLine();
-
-            Console.WriteLine("Please enter the Server ID :");
-            var serverId = Console.ReadLine();
-
-            Config.Data.Add("token", token);
-            Config.Data.Add("prefix", prefix);
-            Config.Data.Add("ServerID", serverId);
-
-            Config.Logger.Log("Config Saved", "Installer", LogLevel.INFO);
-
-            Config.Data.Save();
-
-            Console.WriteLine("Config saved !");
-
-            
-        }
-
-        public static async Task SetupPluginDatabase()
-        {
-            Console.WriteLine("The plugin database is required to run the bot but there is nothing configured yet.");
-            Console.WriteLine("Please select one option : ");
-            Console.WriteLine("1. Download the official database file");
-            Console.WriteLine("2. Create a new (CUSTOM) database file");
-            int choice = 0;
-            Console.Write("Choice : ");
-            choice = int.Parse(Console.ReadLine());
-            if (choice != 1 && choice != 2)
-            {
-                Console.WriteLine("Invalid choice !");
-                Console.WriteLine("Please restart the installer !");
-                Console.ReadKey();
-                Environment.Exit(0);
-            }
-
-            if (choice == 1)
-                await DownloadPluginDatabase();
-
-            if (choice == 2)
-            {
-                Console.WriteLine("Do you have a url to a valid database file ? (y/n)");
-                var answer = Console.ReadLine();
-                if (answer == "y")
-                {
-                    Console.WriteLine("Please enter the url :");
-                    var url = Console.ReadLine();
-                    await DownloadPluginDatabase(url);
-                    return;
-                }
-
-                Console.WriteLine("Do you want to create a new database file ? (y/n)");
-                answer = Console.ReadLine();
-                if (answer == "y")
-                {
-                    Console.WriteLine("A new file will be generated at ./Data/Resources/URLs.json");
-                    System.Console.WriteLine("Please edit the file and restart the bot !");
-                    Directory.CreateDirectory("./Data/Resources");
-                    await File.WriteAllTextAsync("./Data/Resources/URLs.json",
-                    @"
-                    {
-                        ""PluginList"": """",
-                        ""PluginVersions"": """",
-                        ""StartupMessage"": """",
-                        ""SetupKeys"": """",
-                        ""Versions"": """",
-                        ""Changelog"": """",
-                        ""LinuxBot"": """",
-                        ""WindowsLauncher"": """",
-                    }
-                    ".Replace("                    ", ""));
-                    Environment.Exit(0);
-                    return;
-                }
-            }
-        }
-
-        private static async Task DownloadPluginDatabase(string url = "https://raw.githubusercontent.com/Wizzy69/SethDiscordBot/gh-pages/defaultURLs.json")
-        {
-            string path = "./Data/Resources/URLs.json";
-
-            Directory.CreateDirectory("./Data/Resources");
-            Utilities.Utilities.ProgressBar bar = new Utilities.Utilities.ProgressBar(Utilities.ProgressBarType.NORMAL){
-                Max = 100,
-                Color = ConsoleColor.Green,
-                NoColor = true
-            };
-            IProgress<float> downloadProgress = new Progress<float>(p => bar.Update(p));
-            await ServerCom.DownloadFileAsync(url, path, downloadProgress, null);
-            bar.Update(bar.Max);
-        }
-    }
-}

DiscordBot/Program.cs

@@ -1,73 +1,84 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
-using System.Reflection;
-using System.Threading;
-using System.Threading.Tasks;
 using System.Linq;
-
+using System.Threading.Tasks;
+using DiscordBot.Discord.Core;
 using PluginManager;
-using PluginManager.Bot;
+using PluginManager.Items;
 using PluginManager.Online;
-using PluginManager.Online.Helpers;
 using PluginManager.Others;
 
-using DiscordBot.Utilities;
-using Microsoft.VisualBasic.CompilerServices;
-using OperatingSystem = PluginManager.Others.OperatingSystem;
-using static PluginManager.Config;
-
 namespace DiscordBot;
 
 public class Program
 {
-    public static Json<string, string> URLs;
+    private static bool loadPluginsOnStartup;
-    private static bool loadPluginsOnStartup = false;
+    private static bool listPluginsAtStartup;
-    private static ConsoleCommandsHandler consoleCommandsHandler;
 
     /// <summary>
     ///     The main entry point for the application.
     /// </summary>
     [STAThread]
-    public static void Startup(string[] args)
+    [Obsolete]
+    public static void Main(string[] args)
     {
-        PreLoadComponents(args).Wait();
+        Directory.CreateDirectory("./Data/Resources");
+        Directory.CreateDirectory("./Data/Plugins/Commands");
+        Directory.CreateDirectory("./Data/Plugins/Events");
+        PreLoadComponents().Wait();
 
-        if (!Config.Data.ContainsKey("ServerID") || !Config.Data.ContainsKey("token") ||
+        if (!Config.ContainsKey("token") || Config.GetValue<string>("token") == null || Config.GetValue<string>("token")?.Length != 70)
-            Config.Data["token"] == null ||
-            (Config.Data["token"]?.Length != 70 && Config.Data["token"]?.Length != 59) ||
-            !Config.Data.ContainsKey("prefix") || Config.Data["prefix"] == null ||
-            Config.Data["prefix"]?.Length != 1 ||
-            (args.Length == 1 && args[0] == "/reset"))
         {
-            Installer.GenerateStartupConfig();
+            Console.WriteLine("Please insert your token");
+            Console.Write("Token = ");
+            var token = Console.ReadLine();
+            if (token?.Length == 59 || token?.Length == 70)
+                Config.AddValueToVariables("token", token, true);
+            else
+                Console.WriteLine("Invalid token");
+
+            Console.WriteLine("Please insert your prefix (max. 1 character long):");
+            Console.WriteLine("For a prefix longer then one character, the first character will be saved and the others will be ignored.\n No spaces or numbers allowed");
+            Console.Write("Prefix = ");
+            var prefix = Console.ReadLine()![0];
+
+            if (prefix == ' ' || char.IsDigit(prefix)) return;
+            Config.AddValueToVariables("prefix", prefix.ToString(), false);
         }
-        
+
-        HandleInput(args.ToList()).Wait(); 
+        if (!Config.ContainsKey("prefix") || Config.GetValue<string>("prefix") == default)
+        {
+            Console.WriteLine("Please insert your prefix (max. 1 character long):");
+            Console.WriteLine("For a prefix longer then one character, the first character will be saved and the others will be ignored.\n No spaces or numbers allowed");
+            Console.Write("Prefix = ");
+            var prefix = Console.ReadLine()![0];
+            if (prefix == ' ') return;
+            Config.AddValueToVariables("prefix", prefix.ToString(), false);
+        }
+
+
+        HandleInput(args).Wait();
     }
 
     /// <summary>
     ///     The main loop for the discord bot
     /// </summary>
-    private static void NoGUI()
+    /// <param name="discordbooter">The discord booter used to start the application</param>
+    private static Task NoGUI(Boot discordbooter)
     {
-#if DEBUG
+        var consoleCommandsHandler = new ConsoleCommandsHandler(discordbooter.client);
-        Console.WriteLine("Debug mode enabled");
+        if (loadPluginsOnStartup) consoleCommandsHandler.HandleCommand("lp");
+        if (listPluginsAtStartup) consoleCommandsHandler.HandleCommand("listplugs");
+
+        Config.SaveConfig();
 
-#endif
-        if (loadPluginsOnStartup)
-            consoleCommandsHandler.HandleCommand("lp");
 
         while (true)
         {
+            Console.ForegroundColor = ConsoleColor.White;
             var cmd = Console.ReadLine();
-            if (!consoleCommandsHandler.HandleCommand(cmd!
+            if (!consoleCommandsHandler.HandleCommand(cmd))
-#if DEBUG
-                                                    , false
-#endif
-
-            ) && cmd.Length > 0)
                 Console.WriteLine("Failed to run command " + cmd);
         }
     }
@@ -76,253 +87,226 @@ public class Program
     ///     Start the bot without user interface
     /// </summary>
     /// <returns>Returns the boot loader for the Discord Bot</returns>
-    private static async Task<Boot> StartNoGui()
+    private static async Task<Boot> StartNoGUI()
     {
         Console.Clear();
         Console.ForegroundColor = ConsoleColor.DarkYellow;
 
-        var startupMessageList =
+        List<string> startupMessageList = await ServerCom.ReadTextFromFile("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/StartupMessage");
-            await ServerCom.ReadTextFromURL(URLs["StartupMessage"]);
 
-        foreach (var message in startupMessageList)
+        foreach (var message in startupMessageList) Console.WriteLine(message);
-            Console.WriteLine(message);
 
-        Console.WriteLine(
+        Console.WriteLine($"Running on version: {Config.GetValue<string>("Version") ?? System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()}");
-            $"Running on version: {Assembly.GetExecutingAssembly().GetName().Version}");
+        Console.WriteLine($"Git URL: {Config.GetValue<string>("GitURL") ?? " Could not find Git URL"}");
-        Console.WriteLine($"Git URL: {Config.Data["GitURL"]}");
 
-        Utilities.Utilities.WriteColorText(
-            "&rRemember to close the bot using the ShutDown command (&ysd&r) or some settings won't be saved\n");
         Console.ForegroundColor = ConsoleColor.White;
-
+        Console.WriteLine($"============================ LOG ============================");
-        if (Config.Data.ContainsKey("LaunchMessage"))
-            Utilities.Utilities.WriteColorText(Config.Data["LaunchMessage"]);
-
-
-        Utilities.Utilities.WriteColorText(
-            "Please note that the bot saves a backup save file every time you are using the shudown command (&ysd&c)");
-
-        Console.WriteLine("Running on " + Functions.GetOperatingSystem().ToString());
-        Console.WriteLine("============================ LOG ============================");
 
         try
         {
-            string token = "";
+            var token  = Config.GetValue<string>("token");
-#if DEBUG
+            var prefix = Config.GetValue<string>("prefix");
-            if (File.Exists("./Data/Resources/token.txt")) token = File.ReadAllText("./Data/Resources/token.txt");
+
-            else token = Config.Data["token"];
-#else
-            token = Config.Data["token"];
-#endif
-            var prefix = Config.Data["prefix"];
             var discordbooter = new Boot(token, prefix);
             await discordbooter.Awake();
             return discordbooter;
         }
         catch (Exception ex)
         {
-            Config.Logger.Log(ex.ToString(), "Bot", LogLevel.ERROR);
+            Console.WriteLine(ex);
             return null;
         }
     }
 
+    /// <summary>
+    ///     Clear folder
+    /// </summary>
+    /// <param name="d">Directory path</param>
+    private static Task ClearFolder(string d)
+    {
+        var files    = Directory.GetFiles(d);
+        var fileNumb = files.Length;
+        for (var i = 0; i < fileNumb; i++)
+        {
+            File.Delete(files[i]);
+            Console.WriteLine("Deleting : " + files[i]);
+        }
+
+        return Task.CompletedTask;
+    }
+
     /// <summary>
     ///     Handle user input arguments from the startup of the application
     /// </summary>
     /// <param name="args">The arguments</param>
-    private static async Task HandleInput(List<string> args)
+    private static async Task HandleInput(string[] args)
     {
+        var len = args.Length;
 
-        Console.WriteLine("Loading Core ...");
+        if (len == 3 && args[0] == "/download")
-
-        var b = await StartNoGui();
-        consoleCommandsHandler = new ConsoleCommandsHandler(b.client);
-        try
         {
-            if(args.Contains("--gui"))
+            var url      = args[1];
-            {
+            var location = args[2];
-                 // GUI not implemented yet 
+
-                 Console.WriteLine("GUI not implemented yet");
+            await ServerCom.DownloadFileAsync(url, location);
-                 return;
+
-            }
+            return;
-            NoGUI();
         }
-        catch (IOException ex)
+
+        if (len > 0 && (args.Contains("--cmd") || args.Contains("--args") || args.Contains("--nomessage")))
         {
-            if (ex.Message == "No process is on the other end of the pipe." || (uint)ex.HResult == 0x800700E9)
+            if (args.Contains("lp") || args.Contains("loadplugins")) loadPluginsOnStartup = true;
+            if (args.Contains("listplugs")) listPluginsAtStartup                          = true;
+            len = 0;
+        }
+
+
+        if (len == 0 || (args[0] != "--exec" && args[0] != "--execute"))
+        {
+            var b = await StartNoGUI();
+            await NoGUI(b);
+            return;
+        }
+
+
+        Console.ForegroundColor = ConsoleColor.DarkYellow;
+        Console.WriteLine("Execute command interface noGUI\n\n");
+        Console.WriteLine(
+            "\tCommand name\t\t\t\tDescription\n" +
+            "-- help | -help\t\t ------ \tDisplay the help message\n" +
+            "--reset-full\t\t ------ \tReset all files (clear files)\n" +
+            "--reset-logs\t\t ------ \tClear up the output folder\n" +
+            "--start\t\t ------ \tStart the bot\n" +
+            "exit\t\t\t ------ \tClose the application"
+        );
+        while (true)
+        {
+            Console.ForegroundColor = ConsoleColor.White;
+            Console.Write("> ");
+            var message = Console.ReadLine().Split(' ');
+
+            switch (message[0])
             {
-                if (Config.Data.ContainsKey("LaunchMessage"))
+                case "--help":
-                    Config.Data.Add("LaunchMessage",
+                case "-help":
-                                         "An error occured while closing the bot last time. Please consider closing the bot using the &rsd&c method !\nThere is a risk of losing all data or corruption of the save file, which in some cases requires to reinstall the bot !");
+                    Console.ForegroundColor = ConsoleColor.DarkYellow;
-                Config.Logger.Log("An error occured while closing the bot last time. Please consider closing the bot using the &rsd&c method !\nThere is a risk of losing all data or corruption of the save file, which in some cases requires to reinstall the bot !", "Bot", LogLevel.ERROR);
+                    Console.WriteLine(
+                        "\tCommand name\t\t\t\tDescription\n" +
+                        "-- help | -help\t\t ------ \tDisplay the help message\n" +
+                        "--reset-full\t\t ------ \tReset all files (clear files)\n" +
+                        "--reset-settings\t ------ \tReset only bot settings\n" +
+                        "--reset-logs\t\t ------ \tClear up the output folder\n" +
+                        "--start\t\t ------ \tStart the bot\n" +
+                        "exit\t\t\t ------ \tClose the application"
+                    );
+                    break;
+                case "--reset-full":
+                    await ClearFolder("./Data/Resources/");
+                    await ClearFolder("./Output/Logs/");
+                    await ClearFolder("./Output/Errors");
+                    await ClearFolder("./Data/Languages/");
+                    await ClearFolder("./Data/Plugins/Commands");
+                    await ClearFolder("./Data/Plugins/Events");
+                    Console.WriteLine("Successfully cleared all folders");
+                    break;
+                case "--reset-logs":
+                    await ClearFolder("./Output/Logs");
+                    await ClearFolder("./Output/Errors");
+                    Console.WriteLine("Successfully cleard logs folder");
+                    break;
+                case "--exit":
+                case "exit":
+                    Environment.Exit(0);
+                    break;
+                case "--start":
+                    var booter = await StartNoGUI();
+                    await NoGUI(booter);
+                    return;
+
+                default:
+                    Console.WriteLine("Failed to execute command " + message[0]);
+                    break;
             }
         }
-        return;
     }
 
-    private static async Task PreLoadComponents(string[] args)
+    private static async Task PreLoadComponents()
     {
-
+        await Config.LoadConfig();
-        await Config.Initialize();
+        if (Config.ContainsKey("DeleteLogsAtStartup"))
-
+            if (Config.GetValue<bool>("DeleteLogsAtStartup"))
-        if (!Directory.Exists("./Data/Resources") || !File.Exists("./Data/Resources/URLs.json"))
-        {
-            await Installer.SetupPluginDatabase();
-        }
-
-
-        URLs = new Json<string, string>("./Data/Resources/URLs.json");
-
-        Config.Logger.LogEvent += (message, type) => { Console.WriteLine(message); };
-
-
-        Console.WriteLine("Loading resources ...");
-        var main = new Utilities.Utilities.ProgressBar(ProgressBarType.NO_END);
-        main.Start();
-
-        if (Config.Data.ContainsKey("DeleteLogsAtStartup"))
-            if (Config.Data["DeleteLogsAtStartup"] == "true")
                 foreach (var file in Directory.GetFiles("./Output/Logs/"))
                     File.Delete(file);
-        var OnlineDefaultKeys =
+        List<string> OnlineDefaultKeys = await ServerCom.ReadTextFromFile("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/SetupKeys");
-            await ServerCom.ReadTextFromURL(URLs["SetupKeys"]);
 
+        Config.PluginConfig.Load();
 
-        Config.Data["Version"] = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+        if (!Config.ContainsKey("Version"))
+            Config.AddValueToVariables("Version", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(), false);
+        else
+            Config.SetValue("Version", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString());
 
         foreach (var key in OnlineDefaultKeys)
         {
             if (key.Length <= 3 || !key.Contains(' ')) continue;
-            var s = key.Split(' ');
+            string[] s = key.Split(' ');
             try
             {
-                Config.Data[s[0]] = s[1];
+                Config.GetAndAddValueToVariable(s[0], s[1], s[2].Equals("true", StringComparison.CurrentCultureIgnoreCase));
             }
             catch (Exception ex)
             {
-                Config.Logger.Log(ex.ToString(), "Bot", LogLevel.ERROR);
+                Functions.WriteErrFile(ex.Message);
             }
         }
 
-
+        List<string> onlineSettingsList = await ServerCom.ReadTextFromFile("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/OnlineData");
-        var onlineSettingsList = await ServerCom.ReadTextFromURL(URLs["Versions"]);
-        main.Stop("Loaded online settings. Loading updates ...");
         foreach (var key in onlineSettingsList)
         {
             if (key.Length <= 3 || !key.Contains(' ')) continue;
 
-            var s = key.Split(' ');
+            string[] s = key.Split(' ');
             switch (s[0])
             {
                 case "CurrentVersion":
-                    var newVersion = s[1];
+                    string newVersion = s[1];
-                    var currentVersion = Config.Data["Version"];
+                    if (!newVersion.Equals(Config.GetValue<string>("Version")))
-                    if (!newVersion.Equals(currentVersion))
                     {
-                        var nVer = new VersionString(newVersion.Substring(2));
+                        Console.WriteLine("A new version has been released on github page.");
-                        var cVer = new VersionString((Config.Data["Version"]).Substring(2));
+                        Console.WriteLine("Download the new version using the following link wrote in yellow");
-                        if (cVer > nVer)
+                        Console_Utilities.WriteColorText("&y" + Config.GetValue<string>("GitURL") + "&c");
+
+                        Console.WriteLine();
+                        Console.WriteLine("Your product will work just fine on this outdated version, but an update is recommended.\n" +
+                                          "From now on, this version is no longer supported"
+                        );
+                        Console_Utilities.WriteColorText("&rUse at your own risk&c");
+
+                        Console_Utilities.WriteColorText("&mCurrent Version: " + Config.GetValue<string>("Version") + "&c");
+                        Console_Utilities.WriteColorText("&gNew Version: " + newVersion + "&c");
+
+                        Console.WriteLine("\n\n");
+                        await Task.Delay(1000);
+
+                        int waitTime = 20; //wait time to proceed
+
+                        Console.Write($"The bot will start in {waitTime} seconds");
+                        while (waitTime > 0)
                         {
-                            Config.Data["Version"] = "1." + cVer.ToShortString() + " (Beta)";
+                            await Task.Delay(1000);
-                            break;
+                            waitTime--;
+                            Console.SetCursorPosition("The bot will start in ".Length, Console.CursorTop);
+                            Console.Write("                         ");
+                            Console.SetCursorPosition("The bot will start in ".Length, Console.CursorTop);
+                            Console.Write(waitTime + " seconds");
                         }
-
-                        if (OperatingSystem.WINDOWS == Functions.GetOperatingSystem())
-                        {
-                            Console.Clear();
-                            Console.WriteLine("A new update was found !");
-                            Console.WriteLine("Run the launcher to update");
-                            Console.WriteLine("Current version: " + currentVersion);
-                            Console.WriteLine("Latest version: " + s[1]);
-
-                            File.WriteAllText("version.txt", currentVersion);
-
-                            await Task.Delay(3000);
-
-                            break;
-                        }
-
-                        Console.Clear();
-                        Console.ForegroundColor = ConsoleColor.Red;
-                        Console.WriteLine("A new version of the bot is available !");
-                        Console.ForegroundColor = ConsoleColor.Yellow;
-                        Console.WriteLine("Current version : " +
-                                         Assembly.GetExecutingAssembly().GetName().Version.ToString());
-                        Console.ForegroundColor = ConsoleColor.Green;
-                        Console.WriteLine("New version : " + newVersion);
-                        Console.ForegroundColor = ConsoleColor.White;
-
-                        File.WriteAllText("version.txt", newVersion);
-
-                        Console.WriteLine("Changelog :");
-
-                        List<string> changeLog = await ServerCom.ReadTextFromURL(URLs["Changelog"]);
-                        foreach (var item in changeLog)
-                            Utilities.Utilities.WriteColorText(item);
-                        Console.WriteLine("Do you want to update the bot ? (y/n)");
-                        if (Console.ReadKey().Key == ConsoleKey.Y)
-                        {
-                            var url = URLs["LinuxBot"].Replace("{0}", newVersion);
-                            Config.Logger.Log($"executing: download_file {url}");
-
-                            await ServerCom.DownloadFileAsync(url, "./update.zip", new Progress<float>(percent => { Console.WriteLine($"\rProgress: {percent}%        "); }));
-                            await File.WriteAllTextAsync("Install.sh",
-                                                         "#!/bin/bash\nunzip -qq -o update.zip \nrm update.zip\nchmod a+x DiscordBot");
-
-                            try
-                            {
-                                Console.WriteLine("executing: chmod a+x Install.sh");
-                                Process.Start("chmod", "a+x Install.sh").WaitForExit();
-                                Process.Start("Install.sh").WaitForExit();
-
-                                Console.WriteLine("executing: rm Install.sh");
-                                Process.Start("rm", "Install.sh").WaitForExit();
-
-                                Config.Logger.Log("The new version of the bot has been installed.");
-                                Console.WriteLine("Please restart the bot.");
-                                Environment.Exit(0);
-                            }
-                            catch (Exception ex)
-                            {
-                                Config.Logger.Log(ex.Message, "Updater", LogLevel.ERROR);
-                                if (ex.Message.Contains("Access de"))
-                                    Config.Logger.Log("Please run the bot as root.");
-                            }
-
-
-                        }
-                    }
-
-                    break;
-                case "LauncherVersion":
-                    var updaternewversion = s[1];
-                    //File.WriteAllText(updaternewversion + ".txt", updaternewversion);
-                    if (Functions.GetOperatingSystem() == OperatingSystem.LINUX)
-                        break;
-
-                    Directory.CreateDirectory(Functions.dataFolder + "Applications");
-                    if (!Config.Data.ContainsKey("LauncherVersion"))
-                        Config.Data["LauncherVersion"] = "0.0.0.0";
-                    if (Config.Data["LauncherVersion"] != updaternewversion ||
-                        !File.Exists("./Launcher.exe"))
-                    {
-                        Console.Clear();
-                        Console.WriteLine("Installing a new Launcher ...\nDo NOT close the bot during update !");
-                        var bar = new Utilities.Utilities.ProgressBar(ProgressBarType.NO_END);
-                        bar.Start();
-                        await ServerCom.DownloadFileAsync(URLs["WindowsLauncher"], $"./Launcher.exe", null);
-                        //await ArchiveManager.ExtractArchive("./Updater.zip", "./", null,
-                        //                                    UnzipProgressType.PercentageFromTotalSize);
-                        Config.Data["LauncherVersion"] = updaternewversion;
-                        // File.Delete("Updater.zip");
-                        bar.Stop("The launcher has been updated !");
-                        Console.Clear();
                     }
 
                     break;
             }
         }
 
-        Console.Clear();
+
+        Config.SaveConfig();
     }
-}
+}

DiscordBot/Utilities/Command.cs

@@ -1,14 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Discord.Commands;
-using Discord.WebSocket;
-
-namespace DiscordBot.Utilities;
-
-public class ConsoleCommand
-{
-    public string? CommandName { get; init; }
-    public string? Description { get; init; }
-    public string? Usage { get; init; }
-    public Action<string[]>? Action { get; init; }
-}

DiscordBot/Utilities/Console Utilities.cs

@@ -1,399 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-
-using PluginManager;
-
-namespace DiscordBot.Utilities;
-
-public static class Utilities
-{
-    private static Dictionary<char, ConsoleColor> Colors = new()
-    {
-                    { 'g', ConsoleColor.Green },
-                    { 'b', ConsoleColor.Blue },
-                    { 'r', ConsoleColor.Red },
-                    { 'm', ConsoleColor.Magenta },
-                    { 'y', ConsoleColor.Yellow }
-    };
-
-    private static char ColorPrefix = '&';
-
-
-    private static bool CanAproximateTo(this float f, float y)
-    {
-        return MathF.Abs(f - y) < 0.000001;
-    }
-
-
-    /// <summary>
-    ///     A way to create a table based on input data
-    /// </summary>
-    /// <param name="data">The List of arrays of strings that represent the rows.</param>
-    public static void FormatAndAlignTable(List<string[]> data, TableFormat format)
-    {
-        if (format == TableFormat.CENTER_EACH_COLUMN_BASED)
-        {
-            var tableLine = '-';
-            var tableCross = '+';
-            var tableWall = '|';
-
-            var len = new int[data[0].Length];
-            foreach (var line in data)
-                for (var i = 0; i < line.Length; i++)
-                    if (line[i].Length > len[i])
-                        len[i] = line[i].Length;
-
-
-            foreach (var row in data)
-            {
-                if (row[0][0] == tableLine)
-                    Console.Write(tableCross);
-                else
-                    Console.Write(tableWall);
-                for (var l = 0; l < row.Length; l++)
-                {
-                    if (row[l][0] == tableLine)
-                    {
-                        for (var i = 0; i < len[l] + 4; ++i)
-                            Console.Write(tableLine);
-                    }
-                    else if (row[l].Length == len[l])
-                    {
-                        Console.Write("  ");
-                        Console.Write(row[l]);
-                        Console.Write("  ");
-                    }
-                    else
-                    {
-                        var lenHalf = row[l].Length / 2;
-                        for (var i = 0; i < (len[l] + 4) / 2 - lenHalf; ++i)
-                            Console.Write(" ");
-                        Console.Write(row[l]);
-                        for (var i = (len[l] + 4) / 2 + lenHalf + 1; i < len[l] + 4; ++i)
-                            Console.Write(" ");
-                        if (row[l].Length % 2 == 0)
-                            Console.Write(" ");
-                    }
-
-                    Console.Write(row[l][0] == tableLine ? tableCross : tableWall);
-                }
-
-                Console.WriteLine(); //end line
-            }
-
-            return;
-        }
-
-        if (format == TableFormat.CENTER_OVERALL_LENGTH)
-        {
-            var maxLen = 0;
-            foreach (var row in data)
-                foreach (var s in row)
-                    if (s.Length > maxLen)
-                        maxLen = s.Length;
-
-            var div = (maxLen + 4) / 2;
-
-            foreach (var row in data)
-            {
-                Console.Write("\t");
-                if (row[0] == "-")
-                    Console.Write("+");
-                else
-                    Console.Write("|");
-
-                foreach (var s in row)
-                {
-                    if (s == "-")
-                    {
-                        for (var i = 0; i < maxLen + 4; ++i)
-                            Console.Write("-");
-                    }
-                    else if (s.Length == maxLen)
-                    {
-                        Console.Write("  ");
-                        Console.Write(s);
-                        Console.Write("  ");
-                    }
-                    else
-                    {
-                        var lenHalf = s.Length / 2;
-                        for (var i = 0; i < div - lenHalf; ++i)
-                            Console.Write(" ");
-                        Console.Write(s);
-                        for (var i = div + lenHalf + 1; i < maxLen + 4; ++i)
-                            Console.Write(" ");
-                        if (s.Length % 2 == 0)
-                            Console.Write(" ");
-                    }
-
-                    if (s == "-")
-                        Console.Write("+");
-                    else
-                        Console.Write("|");
-                }
-
-                Console.WriteLine(); //end line
-            }
-
-            return;
-        }
-
-        if (format == TableFormat.DEFAULT)
-        {
-            var widths = new int[data[0].Length];
-            var space_between_columns = 3;
-            for (var i = 0; i < data.Count; i++)
-                for (var j = 0; j < data[i].Length; j++)
-                    if (data[i][j].Length > widths[j])
-                        widths[j] = data[i][j].Length;
-
-            for (var i = 0; i < data.Count; i++)
-            {
-                for (var j = 0; j < data[i].Length; j++)
-                {
-                    if (data[i][j] == "-")
-                        data[i][j] = " ";
-                    Console.Write(data[i][j]);
-                    for (var k = 0; k < widths[j] - data[i][j].Length + 1 + space_between_columns; k++)
-                        Console.Write(" ");
-                }
-
-                Console.WriteLine();
-            }
-
-            return;
-        }
-
-        throw new Exception("Unknown type of table");
-    }
-
-    public static void WriteColorText(string text, bool appendNewLineAtEnd = true)
-    {
-        var initialForeGround = Console.ForegroundColor;
-        var input = text.ToCharArray();
-        for (var i = 0; i < input.Length; i++)
-            if (input[i] == ColorPrefix)
-            {
-                if (i + 1 < input.Length)
-                {
-                    if (Colors.ContainsKey(input[i + 1]))
-                    {
-                        Console.ForegroundColor = Colors[input[i + 1]];
-                        i++;
-                    }
-                    else if (input[i + 1] == 'c')
-                    {
-                        Console.ForegroundColor = initialForeGround;
-                        i++;
-                    }
-                }
-            }
-            else
-            {
-                Console.Write(input[i]);
-            }
-
-        Console.ForegroundColor = initialForeGround;
-        if (appendNewLineAtEnd)
-            Console.WriteLine();
-    }
-
-    public class Spinner
-    {
-        private Thread thread;
-        private bool isRunning;
-        private readonly string[] Sequence;
-        private int position;
-
-        public Spinner()
-        {
-            Sequence = new[] {"|", "/", "-", "\\"};
-            position = 0;
-        }
-
-        public void Start()
-        {
-            Console.CursorVisible = false;
-            isRunning=true;
-            thread = new Thread(() => {
-                while (isRunning)
-                {
-                    Console.Write("\r" + Sequence[position]);
-                    position++;
-                    if (position >= Sequence.Length)
-                        position = 0;
-                    Thread.Sleep(100);
-                }
-            });
-
-            thread.Start();
-
-        }
-
-        public void Stop()
-        {
-            isRunning=false;
-            Console.CursorVisible = true;
-        }
-    }
-
-
-    /// <summary>
-    ///     Progress bar object
-    /// </summary>
-    public class ProgressBar
-    {
-        private readonly int BarLength = 32;
-
-        private bool isRunning;
-        private int position = 1;
-        private bool positive = true;
-
-        public ProgressBar(ProgressBarType type)
-        {
-            this.type = type;
-        }
-
-        public float Max { get; init; }
-        public ConsoleColor Color { get; init; }
-        public bool NoColor { get; init; }
-        public ProgressBarType type { get; set; }
-
-        public int TotalLength { get; private set; }
-
-
-        public async void Start()
-        {
-            Console.WriteLine();
-            if (type != ProgressBarType.NO_END)
-                throw new Exception("Only NO_END progress bar can use this method");
-            if (isRunning)
-                throw new Exception("This progress bar is already running");
-
-            isRunning = true;
-            while (isRunning)
-            {
-                UpdateNoEnd();
-                await Task.Delay(100);
-            }
-        }
-
-        public async void Start(string message)
-        {
-            if (type != ProgressBarType.NO_END)
-                throw new Exception("Only NO_END progress bar can use this method");
-            if (isRunning)
-                throw new Exception("This progress bar is already running");
-
-            isRunning = true;
-
-            TotalLength = message.Length + BarLength + 5;
-            while (isRunning)
-            {
-                UpdateNoEnd(message);
-                await Task.Delay(100);
-            }
-        }
-
-        public void Stop()
-        {
-            if (type != ProgressBarType.NO_END)
-                throw new Exception("Only NO_END progress bar can use this method");
-            if (!isRunning)
-                throw new Exception("Can not stop a progressbar that did not start");
-            isRunning = false;
-        }
-
-        public void Stop(string message)
-        {
-            Stop();
-
-            if (message is not null)
-            {
-                Console.CursorLeft = 0;
-                for (var i = 0; i < BarLength + message.Length + 1; i++)
-                    Console.Write(" ");
-                Console.CursorLeft = 0;
-                Console.WriteLine(message);
-            }
-        }
-
-        public void Update(float progress)
-        {
-            if (type == ProgressBarType.NO_END)
-                throw new Exception("This function is for progress bars with end");
-
-            UpdateNormal(progress);
-        }
-
-        private void UpdateNoEnd(string message)
-        {
-            Console.CursorLeft = 0;
-            Console.Write("[");
-            for (var i = 1; i <= position; i++)
-                Console.Write(" ");
-            Console.Write("<==()==>");
-            position += positive ? 1 : -1;
-            for (var i = position; i <= BarLength - 1 - (positive ? 0 : 2); i++)
-                Console.Write(" ");
-            Console.Write("] " + message);
-
-
-            if (position == BarLength - 1 || position == 1)
-                positive = !positive;
-        }
-
-        private void UpdateNoEnd()
-        {
-            Console.CursorLeft = 0;
-            Console.Write("[");
-            for (var i = 1; i <= position; i++)
-                Console.Write(" ");
-            Console.Write("<==()==>");
-            position += positive ? 1 : -1;
-            for (var i = position; i <= BarLength - 1 - (positive ? 0 : 2); i++)
-                Console.Write(" ");
-            Console.Write("]");
-
-
-            if (position == BarLength - 1 || position == 1)
-                positive = !positive;
-        }
-
-        private void UpdateNormal(float progress)
-        {
-            Console.CursorLeft = 0;
-            Console.Write("[");
-            Console.CursorLeft = BarLength;
-            Console.Write("]");
-            Console.CursorLeft = 1;
-            var onechunk = 30.0f / Max;
-
-            var position = 1;
-
-            for (var i = 0; i < onechunk * progress; i++)
-            {
-                Console.BackgroundColor = NoColor ? ConsoleColor.Black : Color;
-                Console.CursorLeft = position++;
-                Console.Write("#");
-            }
-
-            for (var i = position; i < BarLength; i++)
-            {
-                Console.BackgroundColor = NoColor ? ConsoleColor.Black : ConsoleColor.DarkGray;
-                Console.CursorLeft = position++;
-                Console.Write(" ");
-            }
-
-            Console.CursorLeft = BarLength + 4;
-            Console.BackgroundColor = ConsoleColor.Black;
-            if (progress.CanAproximateTo(Max))
-                Console.Write(progress + " %      ✓");
-            else
-                Console.Write(MathF.Round(progress, 2) + " %       ");
-        }
-    }
-}

DiscordBot/Utilities/ConsoleCommandsHandler.cs

@@ -1,439 +0,0 @@
-using System.Threading;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Net.Http;
-using System.Reflection;
-using System.Threading.Tasks;
-
-using Discord.WebSocket;
-
-using PluginManager;
-using PluginManager.Loaders;
-using PluginManager.Online;
-using PluginManager.Others;
-
-using OperatingSystem = PluginManager.Others.OperatingSystem;
-
-namespace DiscordBot.Utilities;
-
-public class ConsoleCommandsHandler
-{
-
-    public static ConsoleCommandsHandler handler;
-    private readonly PluginsManager manager;
-
-    private readonly List<ConsoleCommand> commandList = new();
-
-
-    private bool isDownloading;
-    private bool pluginsLoaded;
-    private DiscordSocketClient client;
-
-    public ConsoleCommandsHandler(DiscordSocketClient client)
-    {
-        this.client = client;
-        
-        manager = new PluginsManager(Program.URLs["PluginList"], Program.URLs["PluginVersions"]);
-        InitializeBasicCommands();
-        Console.WriteLine("Done");
-
-        if (handler == null)
-            handler = this;
-        else
-            throw new Exception("ConsoleCommandsHandler already initialized");
-    }
-
-    private void InitializeBasicCommands()
-    {
-        commandList.Clear();
-
-        AddCommand("help", "Show help", "help <command>", args =>
-            {
-                if (args.Length <= 1)
-                {
-                    Console.WriteLine("Available commands:");
-                    var items = new List<string[]>
-                    {
-                        new[] { "-", "-", "-" },
-                        new[] { "Command", "Description", "Usage" },
-                        new[] { " ", " ", "Argument type: <optional> [required]" },
-                        new[] { "-", "-", "-" }
-                    };
-
-                    foreach (var command in commandList)
-                    {
-                        if (!command.CommandName.StartsWith("_"))
-                            items.Add(new[] { command.CommandName, command.Description, command.Usage });
-                    }
-
-                    items.Add(new[] { "-", "-", "-" });
-                    Utilities.FormatAndAlignTable(items, TableFormat.DEFAULT);
-                }
-                else
-                {
-                    foreach (var command in commandList)
-                        if (command.CommandName == args[1])
-                        {
-                            Console.WriteLine("Command description: " + command.Description);
-                            Console.WriteLine("Command execution format:" + command.Usage);
-                            return;
-                        }
-
-                    Console.WriteLine("Command not found");
-                }
-            }
-        );
-
-        AddCommand("lp", "Load plugins", () =>
-            {
-                if (pluginsLoaded)
-                    return;
-                var loader = new PluginLoader(client!);
-                var cc = Console.ForegroundColor;
-                loader.onCMDLoad += (name, typeName, success, exception) =>
-                {
-                    if (name == null || name.Length < 2)
-                        name = typeName;
-                    if (success)
-                    {
-                        Console.ForegroundColor = ConsoleColor.Green;
-                        Console.WriteLine("[CMD] Successfully loaded command : " + name);
-                    }
-
-                    else
-                    {
-                        Console.ForegroundColor = ConsoleColor.Red;
-                        if (exception is null)
-                            Console.WriteLine("An error occured while loading: " + name);
-                        else
-                            Console.WriteLine("[CMD] Failed to load command : " + name + " because " + exception!.Message);
-                    }
-
-                    Console.ForegroundColor = cc;
-                };
-                loader.onEVELoad += (name, typeName, success, exception) =>
-                {
-                    if (name == null || name.Length < 2)
-                        name = typeName;
-
-                    if (success)
-                    {
-                        Console.ForegroundColor = ConsoleColor.Green;
-                        Console.WriteLine("[EVENT] Successfully loaded event : " + name);
-                    }
-                    else
-                    {
-                        Console.ForegroundColor = ConsoleColor.Red;
-                        Console.WriteLine("[EVENT] Failed to load event : " + name + " because " + exception!.Message);
-                    }
-
-                    Console.ForegroundColor = cc;
-                };
-
-                loader.onSLSHLoad += (name, typeName, success, exception) =>
-                {
-                    if (name == null || name.Length < 2)
-                        name = typeName;
-
-                    if (success)
-                    {
-                        Console.ForegroundColor = ConsoleColor.Green;
-                        Console.WriteLine("[SLASH] Successfully loaded command : " + name);
-                    }
-                    else
-                    {
-                        Console.ForegroundColor = ConsoleColor.Red;
-                        Console.WriteLine("[SLASH] Failed to load command : " + name + " because " + exception!.Message);
-                    }
-
-                    Console.ForegroundColor = cc;
-                };
-
-                loader.LoadPlugins();
-                Console.ForegroundColor = cc;
-                pluginsLoaded = true;
-            }
-        );
-
-        AddCommand("listplugs", "list available plugins", async () => {
-            if(manager == null)
-            {
-                Console.WriteLine("Plugin manager is null");
-                return;
-            }
-            var data = await manager.GetAvailablePlugins();
-            var items = new List<string[]>
-            {
-                new[] { "-", "-", "-", "-" },
-                new[] { "Name", "Type", "Description", "Required" },
-                new[] { "-", "-", "-", "-" }
-            };
-
-            foreach (var plugin in data)
-            {
-                items.Add(new[] { plugin[0], plugin[1], plugin[2], plugin[3] });
-            }
-
-            items.Add(new[] { "-", "-", "-", "-" });
-            Utilities.FormatAndAlignTable(items, TableFormat.DEFAULT);
-        });
-
-        AddCommand("dwplug", "download plugin", "dwplug [name]", async args =>
-            {
-                isDownloading = true;
-                Utilities.Spinner spinner = new Utilities.Spinner();
-                if (args.Length == 1)
-                {
-                    isDownloading = false;
-                    Console.WriteLine("Please specify plugin name");
-                    return;
-                }
-
-                var name = string.Join(' ', args, 1, args.Length - 1);
-                // info[0] = plugin type
-                // info[1] = plugin link
-                // info[2] = if others are required, or string.Empty if none
-                var info = await manager.GetPluginLinkByName(name);
-                if (info[1] == null) // link is null
-                {
-                    if (name == "")
-                    {
-                        isDownloading = false;
-                        Utilities.WriteColorText("Name is invalid");
-                        return;
-                    }
-
-                    isDownloading = false;
-                    Utilities.WriteColorText($"Failed to find plugin &b{name} &c!" +
-                                                     " Use &glistplugs &ccommand to display all available plugins !");
-                    return;
-                }
-
-                spinner.Start();
-
-                string path;
-                if (info[0] == "Plugin")
-                    path = "./Data/Plugins/" + name + ".dll";
-                else
-                    path = $"./{info[1].Split('/')[info[1].Split('/').Length - 1]}";
-
-                
-                Console.WriteLine($"Downloading plugin {name} from {info[1]} to {path}");
-                await ServerCom.DownloadFileAsync(info[1], path, null);
-
-                Console.WriteLine("\n");
-
-                // check requirements if any
-
-                if (info.Length == 3 && info[2] != string.Empty && info[2] != null)
-                {
-                    Console.WriteLine($"Downloading requirements for plugin : {name}");
-
-                    var lines = await ServerCom.ReadTextFromURL(info[2]);
-
-                    foreach (var line in lines)
-                    {
-                        if (!(line.Length > 0 && line.Contains(",")))
-                            continue;
-                        var split = line.Split(',');
-                        Console.WriteLine($"\nDownloading item: {split[1]}");
-                        if (File.Exists("./" + split[1])) File.Delete("./" + split[1]);
-                        await ServerCom.DownloadFileAsync(split[0], "./" + split[1], null);
-                            
-                        Console.WriteLine("Item " + split[1] + " downloaded !");
-
-                        Console.WriteLine();
-                        if (split[0].EndsWith(".pak"))
-                        {
-                            File.Move("./" + split[1], "./Data/PAKS/" + split[1], true);
-                        }
-                        else if (split[0].EndsWith(".zip") || split[0].EndsWith(".pkg"))
-                        {
-                            Console.WriteLine($"Extracting {split[1]} ...");
-                            await ArchiveManager.ExtractArchive("./" + split[1], "./", null,
-                                                           UnzipProgressType.PERCENTAGE_FROM_TOTAL_SIZE);
-                            Console.WriteLine("\n");
-                            File.Delete("./" + split[1]);
-                        }
-                    }
-
-                    Console.WriteLine();
-                }
-                spinner.Stop();
-
-                var ver = await manager.GetVersionOfPackageFromWeb(name);
-                if (ver is null) throw new Exception("Incorrect version");
-                    Config.Plugins[name] = ver.ToShortString();
-
-                isDownloading = false;
-                
-
-                Config.Logger.Log("Plugin installed !", this, LogLevel.INFO);
-
-                //await ExecuteCommad("localload " + name);
-            }
-        );
-
-
-        AddCommand("value", "read value from VariableStack", "value [key]", args =>
-            {
-                if (args.Length != 2)
-                    return;
-                if (!Config.Data.ContainsKey(args[1]))
-                    return;
-
-                var data = Config.Data[args[1]];
-                Console.WriteLine($"{args[1]} => {data}");
-            }
-        );
-
-        AddCommand("add", "add variable to the system variables", "add [key] [value]", args =>
-            {
-                if (args.Length < 4)
-                    return;
-                var key = args[1];
-                var value = args[2];
-                var isReadOnly = args[3].Equals("true", StringComparison.CurrentCultureIgnoreCase);
-
-                try
-                {
-                    Config.Data[key] = value;
-                    Console.WriteLine($"Updated config file with the following command: {args[1]} => {value}");
-                }
-                catch (Exception ex)
-                {
-                    Console.WriteLine(ex.ToString());
-                }
-            }
-        );
-
-        AddCommand("remv", "remove variable from system variables", "remv [key]", args =>
-            {
-                if (args.Length < 2)
-                    return;
-                Config.Data.Remove(args[1]);
-            }
-        );
-
-        AddCommand("sd", "Shuts down the discord bot", async () =>
-            {
-                if (client is null)
-                    return;
-
-                await Functions.SaveToJsonFile(Functions.dataFolder + "config.json", Config.Data);
-                await Functions.SaveToJsonFile(Functions.dataFolder + "Plugins.json", Config.Plugins);
-                await client.StopAsync();
-                await client.DisposeAsync();
-
-                Config.Logger.SaveToFile();
-                await Task.Delay(1000);
-                Environment.Exit(0);
-            }
-        );
-
-        AddCommand("import", "Load an external command", "import [pluginName]", async args =>
-        {
-            if (args.Length <= 1) return;
-            try
-            {
-                var pName = string.Join(' ', args, 1, args.Length - 1);
-                using (var client = new HttpClient())
-                {
-                    var url = (await manager.GetPluginLinkByName(pName))[1];
-                    if (url is null) throw new Exception($"Invalid plugin name {pName}.");
-                    var s = await client.GetStreamAsync(url);
-                    var str = new MemoryStream();
-                    await s.CopyToAsync(str);
-                    var asmb = Assembly.Load(str.ToArray());
-
-                    await PluginLoader.LoadPluginFromAssembly(asmb, this.client);
-                }
-
-
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine(ex.Message);
-            }
-        });
-
-        AddCommand("localload", "Load a local command", "local [pluginName]", async args =>
-        {
-            if (args.Length <= 1) return;
-            try
-            {
-                var pName = string.Join(' ', args, 1, args.Length - 1);
-                var asmb = Assembly.LoadFile(Path.GetFullPath("./Data/Plugins/" + pName + ".dll"));
-
-                await PluginLoader.LoadPluginFromAssembly(asmb, this.client);
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine(ex.Message);
-                Config.Logger.Log(ex.Message, this, LogLevel.ERROR);
-            }
-        });
-
-
-        commandList.Sort((x, y) => x.CommandName.CompareTo(y.CommandName));
-    }
-
-    public void AddCommand(string command, string description, string usage, Action<string[]> action)
-    {
-        Console.WriteLine($"Adding command {command} ...");
-        commandList.Add(new ConsoleCommand
-        { CommandName = command, Description = description, Action = action, Usage = usage });
-        Console.ForegroundColor = ConsoleColor.White;
-        Utilities.WriteColorText($"Command &r{command} &cadded to the list of commands");
-    }
-
-    public void AddCommand(string command, string description, Action action)
-    {
-        AddCommand(command, description, command, args => action());
-    }
-
-    public void RemoveCommand(string command)
-    {
-        commandList.RemoveAll(x => x.CommandName == command);
-    }
-
-    public bool CommandExists(string command)
-    {
-        return GetCommand(command) is not null;
-    }
-
-    public ConsoleCommand? GetCommand(string command)
-    {
-        return commandList.FirstOrDefault(t => t.CommandName == command);
-    }
-
-    public bool HandleCommand(string command, bool removeCommandExecution = true)
-    {
-        Console.ForegroundColor = ConsoleColor.White;
-        var args = command.Split(' ');
-        foreach (var item in commandList.ToList())
-            if (item.CommandName == args[0])
-            {
-                if (args[0].StartsWith("_"))
-                    throw new Exception("This command is reserved for internal worker and can not be executed manually !");
-
-                    if (removeCommandExecution)
-                    {
-                        Console.SetCursorPosition(0, Console.CursorTop - 1);
-                        for (var i = 0; i < command.Length + 30; i++)
-                            Console.Write(" ");
-                        Console.SetCursorPosition(0, Console.CursorTop);
-                    }
-
-                Console.WriteLine();
-                item.Action(args);
-
-                return true;
-            }
-
-        return false;
-    }
-}

DiscordBot/Utilities/Enums.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace DiscordBot.Utilities
-{
-    public enum TableFormat
-    {
-        CENTER_EACH_COLUMN_BASED,
-        CENTER_OVERALL_LENGTH,
-        DEFAULT
-    }
-
-    public enum ProgressBarType
-    {
-        NORMAL,
-        NO_END
-    }
-}

DiscordBotWithAPI.sln

@@ -0,0 +1,69 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32421.90
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DiscordBot", "DiscordBot\DiscordBot.csproj", "{087E64F4-1E1C-4899-8223-295356C9894A}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PluginManager", "PluginManager\PluginManager.csproj", "{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Plugins", "Plugins", "{1862ABD5-7C30-4F15-A561-45AC8A9CA10E}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Events", "Events", "{A290C028-77C4-4D1D-AB43-DDFE6ABD9012}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Commands", "Commands", "{449FA364-0B72-43FF-B3A3-806E2916200E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CMD_Utils", "CMD_Utils\CMD_Utils.csproj", "{E26C87A4-3DD6-4B58-B14B-C8E086B852F9}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MusicCommands", "MusicCommands\MusicCommands.csproj", "{B1B4976E-5112-4217-B57B-3A03C5207B6E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EVE_LevelingSystem", "EVE_LevelingSystem\EVE_LevelingSystem.csproj", "{EEC445DC-0C4B-43EA-8694-606BA0390B77}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CMD_LevelingSystem", "CMD_LevelingSystem\CMD_LevelingSystem.csproj", "{1A4E49FF-9A0A-4C54-AF35-CFFBA64353D9}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{087E64F4-1E1C-4899-8223-295356C9894A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{087E64F4-1E1C-4899-8223-295356C9894A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{087E64F4-1E1C-4899-8223-295356C9894A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{087E64F4-1E1C-4899-8223-295356C9894A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E26C87A4-3DD6-4B58-B14B-C8E086B852F9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E26C87A4-3DD6-4B58-B14B-C8E086B852F9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E26C87A4-3DD6-4B58-B14B-C8E086B852F9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E26C87A4-3DD6-4B58-B14B-C8E086B852F9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B1B4976E-5112-4217-B57B-3A03C5207B6E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B1B4976E-5112-4217-B57B-3A03C5207B6E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B1B4976E-5112-4217-B57B-3A03C5207B6E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B1B4976E-5112-4217-B57B-3A03C5207B6E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EEC445DC-0C4B-43EA-8694-606BA0390B77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EEC445DC-0C4B-43EA-8694-606BA0390B77}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EEC445DC-0C4B-43EA-8694-606BA0390B77}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EEC445DC-0C4B-43EA-8694-606BA0390B77}.Release|Any CPU.Build.0 = Release|Any CPU
+		{1A4E49FF-9A0A-4C54-AF35-CFFBA64353D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1A4E49FF-9A0A-4C54-AF35-CFFBA64353D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1A4E49FF-9A0A-4C54-AF35-CFFBA64353D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1A4E49FF-9A0A-4C54-AF35-CFFBA64353D9}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{A290C028-77C4-4D1D-AB43-DDFE6ABD9012} = {1862ABD5-7C30-4F15-A561-45AC8A9CA10E}
+		{449FA364-0B72-43FF-B3A3-806E2916200E} = {1862ABD5-7C30-4F15-A561-45AC8A9CA10E}
+		{E26C87A4-3DD6-4B58-B14B-C8E086B852F9} = {449FA364-0B72-43FF-B3A3-806E2916200E}
+		{B1B4976E-5112-4217-B57B-3A03C5207B6E} = {449FA364-0B72-43FF-B3A3-806E2916200E}
+		{EEC445DC-0C4B-43EA-8694-606BA0390B77} = {A290C028-77C4-4D1D-AB43-DDFE6ABD9012}
+		{1A4E49FF-9A0A-4C54-AF35-CFFBA64353D9} = {449FA364-0B72-43FF-B3A3-806E2916200E}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3FB3C5DE-ED21-4D2E-ABDD-3A00EE4A2FFF}
+	EndGlobalSection
+EndGlobal

EVE_LevelingSystem/EVE_LevelingSystem.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <BaseOutputPath>..\DiscordBot\bin\Debug\net6.0\Data\Plugins\Events\LevelingSystem</BaseOutputPath>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="bin\**" />
+    <EmbeddedResource Remove="bin\**" />
+    <None Remove="bin\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PluginManager\PluginManager.csproj" />
+  </ItemGroup>
+
+</Project>

EVE_LevelingSystem/Level.cs

@@ -0,0 +1,54 @@
+using Discord;
+using Discord.WebSocket;
+using EVE_LevelingSystem.LevelingSystemCore;
+using PluginManager;
+using PluginManager.Interfaces;
+using PluginManager.Others;
+
+namespace EVE_LevelingSystem
+{
+    internal class Level : DBEvent
+    {
+        public          string   name        => "Leveling System Event Handler";
+        public          string   description => "The Leveling System Event Handler";
+        internal static Settings globalSettings = new();
+
+
+        public async void Start(DiscordSocketClient client)
+        {
+            Directory.CreateDirectory("./Data/Resources/LevelingSystem");
+            Config.AddValueToVariables("LevelingSystemPath", "./Data/Resources/LevelingSystem", true);
+            Config.AddValueToVariables("LevelingSystemSettingsFile", "./Data/Resources/LevelingSystemSettings.txt", true);
+
+            if (!File.Exists(Config.GetValue<string>("LevelingSystemSettingsFile")))
+            {
+                globalSettings = new Settings { TimeToWaitBetweenMessages = 5 };
+                await Functions.SaveToJsonFile<Settings>(Config.GetValue<string>("LevelingSystemSettingsFile"), globalSettings);
+            }
+            else
+                globalSettings = await Functions.ConvertFromJson<Settings>(Config.GetValue<string>("LevelingSystemSettingsFile"));
+
+            // Console.WriteLine(globalSettings.TimeToWaitBetweenMessages);
+            client.MessageReceived += ClientOnMessageReceived;
+        }
+
+        private async Task ClientOnMessageReceived(SocketMessage arg)
+        {
+            if (arg.Author.IsBot || arg.IsTTS || arg.Content.StartsWith(Config.GetValue<string>("prefix"))) return;
+            string userID = arg.Author.Id.ToString();
+            User   user;
+            if (File.Exists($"{Config.GetValue<string>("LevelingSystemPath")}/{userID}.dat"))
+            {
+                user = await Functions.ConvertFromJson<User>(Config.GetValue<string>("LevelingSystemPath")! + $"/{userID}.dat");
+                // Console.WriteLine(Config.GetValue("LevelingSystemPath"));
+                if (user.AddEXP()) await arg.Channel.SendMessageAsync($"{arg.Author.Mention} is now level {user.CurrentLevel}");
+                await Functions.SaveToJsonFile(Config.GetValue<string>("LevelingSystemPath") + $"/{userID}.dat", user);
+                return;
+            }
+
+            user = new User { CurrentEXP = 0, CurrentLevel = 1, RequiredEXPToLevelUp = LevelCalculator.GetNextLevelRequiredEXP(1), user = new DiscordUser { DiscordTag = arg.Author.DiscriminatorValue, userID = arg.Author.Id, Username = arg.Author.Username } };
+            if (user.AddEXP()) await arg.Channel.SendMessageAsync($"{arg.Author.Mention} is now level {user.CurrentLevel}");
+            await Functions.SaveToJsonFile<User>($"{Config.GetValue<string>("LevelingSystemPath")}/{userID}.dat", user);
+        }
+    }
+}

EVE_LevelingSystem/LevelingSystemCore/LevelCalculator.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using PluginManager;
+
+namespace EVE_LevelingSystem.LevelingSystemCore
+{
+    internal static class LevelCalculator
+    {
+        internal static List<string> OnWaitingList = new();
+
+        internal static Int64 GetNextLevelRequiredEXP(int currentLevel)
+        {
+            return currentLevel * 8 + 24;
+        }
+
+        internal static void LevelUp(this User user)
+        {
+            user.CurrentEXP           = 0;
+            user.RequiredEXPToLevelUp = GetNextLevelRequiredEXP(user.CurrentLevel);
+            user.CurrentLevel++;
+        }
+
+        internal static bool AddEXP(this User user)
+        {
+            if (OnWaitingList.Contains(user.user.userID.ToString())) return false;
+            Random r      = new Random();
+            int    exp    = r.Next(2, 12);
+            Int64  userXP = user.CurrentEXP;
+            Int64  reqEXP = user.RequiredEXPToLevelUp;
+            if (userXP + exp >= reqEXP)
+            {
+                user.LevelUp();
+                user.CurrentEXP = exp - (reqEXP - userXP);
+                Console.WriteLine("Level up");
+                return true;
+            }
+
+            user.CurrentEXP += exp;
+
+            OnWaitingList.Add(user.user.userID.ToString());
+
+
+            new Thread(() =>
+                {
+                    int minutesToWait = Level.globalSettings.TimeToWaitBetweenMessages;
+                    Thread.Sleep(60000 * minutesToWait);
+                    OnWaitingList.Remove(user.user.userID.ToString());
+                }
+            );
+
+            return false;
+        }
+    }
+}

EVE_LevelingSystem/LevelingSystemCore/User.cs

@@ -0,0 +1,20 @@
+using Discord;
+using Discord.WebSocket;
+
+namespace EVE_LevelingSystem.LevelingSystemCore
+{
+    public class DiscordUser
+    {
+        public string Username   { get; set; }
+        public ushort DiscordTag { get; set; }
+        public ulong  userID     { get; set; }
+    }
+
+    public class User
+    {
+        public DiscordUser user                 { get; set; }
+        public int         CurrentLevel         { get; set; }
+        public long        CurrentEXP           { get; set; }
+        public long        RequiredEXPToLevelUp { get; set; }
+    }
+}

EVE_LevelingSystem/Settings.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EVE_LevelingSystem
+{
+    public class Settings
+    {
+        public int TimeToWaitBetweenMessages { get; set; }
+    }
+}

MusicCommands/Data.cs

@@ -0,0 +1,12 @@
+using Discord;
+using Discord.Audio;
+
+namespace MusicCommands;
+
+internal static class Data
+{
+    internal static IAudioClient  audioClient  = null;
+    internal static IVoiceChannel voiceChannel = null;
+
+    internal static MusicPlayer CurrentlyRunning = null;
+}

MusicCommands/Leave.cs

@@ -0,0 +1,31 @@
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+namespace MusicCommands;
+
+internal class Leave : DBCommand
+{
+    public string Command => "leave";
+
+    public string Description => "Leave the voice channel";
+
+    public string Usage => "leave";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        if (Data.audioClient is not null && Data.voiceChannel is not null)
+        {
+            Data.CurrentlyRunning.Stop();
+            Data.CurrentlyRunning = null;
+            await Data.audioClient.StopAsync();
+            await Data.voiceChannel.DisconnectAsync();
+        }
+    }
+}

MusicCommands/MusicCommands.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>warnings</Nullable>
+    <BaseOutputPath>..\DiscordBot\bin\Debug\net6.0\Data\Plugins\Commands\MusicCommands</BaseOutputPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <OutputPath>../BUILDS/</OutputPath>
+    <ErrorReport>none</ErrorReport>
+    <DebugType>none</DebugType>
+    <DebugSymbols>false</DebugSymbols>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PluginManager\PluginManager.csproj" />
+  </ItemGroup>
+
+</Project>

MusicCommands/MusicPlayer.cs

@@ -0,0 +1,118 @@
+using System;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using PluginManager.Others;
+
+namespace MusicCommands;
+
+internal class MusicPlayer
+{
+    public MusicPlayer(Stream input, Stream output)
+    {
+        inputStream  = input;
+        outputStream = output;
+    }
+
+    public MusicPlayer(Stream output)
+    {
+        inputStream  = null;
+        outputStream = output;
+    }
+
+    public Stream inputStream  { get; } // from FFMPEG
+    public Stream outputStream { get; } // to Voice Channel 
+
+    public  bool Paused { get; set; }
+    private bool _stop  { get; set; }
+
+    public void Stop()
+    {
+        _stop = true;
+    }
+
+    public async Task StartSendAudioFromLink(string URL)
+    {
+        /*            using (HttpClient client = new HttpClient())
+                    using (HttpResponseMessage response = await client.GetAsync(URL))
+                    using (var content = response.Content)
+                    {
+                        await (await content.ReadAsStreamAsync()).CopyToAsync(outputStream);
+                    }*/
+
+
+        Stream ms    = new MemoryStream();
+        var    bsize = 512;
+        new Thread(async delegate(object o)
+            {
+                var response = await new HttpClient().GetAsync(URL);
+                using (var stream = await response.Content.ReadAsStreamAsync())
+                {
+                    var buffer = new byte[bsize];
+                    int read;
+                    while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
+                    {
+                        var pos = ms.Position;
+                        ms.Position = ms.Length;
+                        ms.Write(buffer, 0, read);
+                        ms.Position = pos;
+                    }
+                }
+            }
+        ).Start();
+        Console.Write("Reading data: ");
+        while (ms.Length < bsize * 10)
+        {
+            await Task.Delay(1000);
+            Console.Title = "Reading data: " + ms.Length + " bytes read of " + bsize * 10;
+            Console.Write(".");
+        }
+
+        Console.WriteLine("\nDone");
+        ms.Position = 0;
+
+        _stop  = false;
+        Paused = false;
+
+        while (!_stop)
+        {
+            if (Paused) continue;
+            var buffer = new byte[bsize];
+            var read   = await ms.ReadAsync(buffer, 0, buffer.Length);
+            if (read > 0)
+                await outputStream.WriteAsync(buffer, 0, read);
+            else
+                break;
+        }
+    }
+
+    public async Task StartSendAudio()
+    {
+        Paused = false;
+        _stop  = false;
+        while (!_stop)
+        {
+            if (Paused) continue;
+            var bsize  = 512;
+            var buffer = new byte[bsize];
+            var bcount = await inputStream.ReadAsync(buffer, 0, bsize);
+            if (bcount <= 0)
+            {
+                Stop();
+                Data.CurrentlyRunning = null;
+                break;
+            }
+
+            try
+            {
+                await outputStream.WriteAsync(buffer, 0, bcount);
+            }
+            catch (Exception ex)
+            {
+                await outputStream.FlushAsync();
+                Functions.WriteLogFile(ex.ToString());
+            }
+        }
+    }
+}

MusicCommands/Pause.cs

@@ -0,0 +1,25 @@
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+namespace MusicCommands;
+
+internal class Pause : DBCommand
+{
+    public string Command => "pause";
+
+    public string Description => "Pause the music";
+
+    public string Usage => "pause";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        Data.CurrentlyRunning.Paused = true;
+    }
+}

MusicCommands/Play.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using Discord;
+using Discord.Audio;
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+using PluginManager.Others;
+
+namespace MusicCommands;
+
+internal class Play : DBCommand
+{
+    public string Command => "fplay";
+
+    public string Description => "Play music from a file";
+
+    public string Usage => "fplay [name]";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        var path     = "./Music";
+        var FileName = Functions.GetArguments(message).ToArray().MergeStrings(0);
+        path += "/" + FileName + ".ogg";
+        if (!File.Exists(path))
+        {
+            Console.WriteLine("Unknown path " + path);
+            return;
+        }
+
+
+        Data.voiceChannel = (context.User as IGuildUser)?.VoiceChannel;
+        if (Data.voiceChannel == null)
+        {
+            await context.Channel.SendMessageAsync("User must be in a voice channel, or a voice channel must be passed as an argument.");
+            return;
+        }
+
+        Data.audioClient = await Data.voiceChannel.ConnectAsync();
+
+        using (var ffmpeg = CreateStream(path))
+        using (var output = ffmpeg.StandardOutput.BaseStream)
+        using (var discord = Data.audioClient.CreatePCMStream(AudioApplication.Mixed))
+        {
+            if (Data.CurrentlyRunning != null) Data.CurrentlyRunning.Stop();
+            Data.CurrentlyRunning = new MusicPlayer(output, discord);
+            await Data.CurrentlyRunning.StartSendAudio();
+        }
+    }
+
+    private Process CreateStream(string path)
+    {
+        return Process.Start(new ProcessStartInfo { FileName = "ffmpeg", Arguments = $"-hide_banner -loglevel panic -i \"{path}\" -ac 2 -f s16le -ar 48000 pipe:1", UseShellExecute = false, RedirectStandardOutput = true });
+    }
+}

MusicCommands/Unpause.cs

@@ -0,0 +1,25 @@
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+namespace MusicCommands;
+
+internal class Unpause : DBCommand
+{
+    public string Command => "unpause";
+
+    public string Description => "Unpause the music";
+
+    public string Usage => "unpause";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => true;
+
+    public bool requireAdmin => false;
+
+    public void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        Data.CurrentlyRunning.Paused = false;
+    }
+}

MusicCommands/lplay.cs

@@ -0,0 +1,49 @@
+using Discord;
+using Discord.Audio;
+using Discord.Commands;
+using Discord.WebSocket;
+using PluginManager.Interfaces;
+
+namespace MusicCommands;
+
+internal class lplay : DBCommand
+{
+    public string Command => "lplay";
+
+    public string Description => "Play music from a link";
+
+    public string Usage => "lplay [url]";
+
+    public bool canUseDM => false;
+
+    public bool canUseServer => false;
+
+    public bool requireAdmin => false;
+
+    public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
+    {
+        var URL = message.Content.Split(' ')[1];
+        if (!URL.EndsWith(".mp3") && !URL.EndsWith(".wav") && !URL.EndsWith(".flac") && !URL.EndsWith(".ogg"))
+        {
+            await message.Channel.SendMessageAsync("Invalid URL");
+            return;
+        }
+
+        Data.voiceChannel = (context.User as IGuildUser)?.VoiceChannel;
+        if (Data.voiceChannel == null)
+        {
+            await context.Channel.SendMessageAsync("User must be in a voice channel, or a voice channel must be passed as an argument.");
+            return;
+        }
+
+        Data.audioClient = await Data.voiceChannel.ConnectAsync();
+
+        using (var discord = Data.audioClient.CreatePCMStream(AudioApplication.Mixed))
+        {
+            await message.Channel.SendMessageAsync("Loading...");
+
+            Data.CurrentlyRunning = new MusicPlayer(discord);
+            await Data.CurrentlyRunning.StartSendAudioFromLink(URL);
+        }
+    }
+}

PluginManager/Bot/CommandHandler.cs

@@ -1,150 +0,0 @@
-using System;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
-
-using Discord.Commands;
-using Discord.WebSocket;
-using PluginManager.Interfaces;
-using PluginManager.Loaders;
-using PluginManager.Others;
-using PluginManager.Others.Permissions;
-
-namespace PluginManager.Bot;
-
-internal class CommandHandler
-{
-    private readonly string botPrefix;
-    private readonly DiscordSocketClient client;
-    private readonly CommandService commandService;
-
-    /// <summary>
-    ///     Command handler constructor
-    /// </summary>
-    /// <param name="client">The discord bot client</param>
-    /// <param name="commandService">The discord bot command service</param>
-    /// <param name="botPrefix">The prefix to watch for</param>
-    public CommandHandler(DiscordSocketClient client, CommandService commandService, string botPrefix)
-    {
-        this.client = client;
-        this.commandService = commandService;
-        this.botPrefix = botPrefix;
-
-    }
-
-    /// <summary>
-    ///     The method to initialize all commands
-    /// </summary>
-    /// <returns></returns>
-    public async Task InstallCommandsAsync()
-    {
-        client.MessageReceived += MessageHandler;
-        client.SlashCommandExecuted += Client_SlashCommandExecuted;
-        await commandService.AddModulesAsync(Assembly.GetEntryAssembly(), null);
-    }
-
-    private Task Client_SlashCommandExecuted(SocketSlashCommand arg)
-    {
-        try
-        {
-            var plugin = PluginLoader.SlashCommands!
-             .Where(p => p.Name == arg.Data.Name)
-             .FirstOrDefault();
-
-            if (plugin is null)
-                throw new Exception("Failed to run command. !");
-
-
-            if (arg.Channel is SocketDMChannel)
-                plugin.ExecuteDM(arg);
-            else plugin.ExecuteServer(arg);
-        }
-        catch (Exception ex)
-        {
-            Config.Logger.Log(ex.Message, "CommandHandler", LogLevel.ERROR);
-        }
-
-        return Task.CompletedTask;
-
-    }
-
-    /// <summary>
-    ///     The message handler for the bot
-    /// </summary>
-    /// <param name="Message">The message got from the user in discord chat</param>
-    /// <returns></returns>
-    private async Task MessageHandler(SocketMessage Message)
-    {
-
-        try
-        {
-            if (Message.Author.IsBot) 
-                return;
-
-            if (Message as SocketUserMessage == null)
-                return;
-
-            var message = Message as SocketUserMessage;
-
-            if (message is null)
-                return;
-
-            var argPos = 0;
-
-            if (!message.Content.StartsWith(botPrefix) && !message.HasMentionPrefix(client.CurrentUser, ref argPos))
-                return;
-
-            var context = new SocketCommandContext(client, message);
-
-            await commandService.ExecuteAsync(context, argPos, null);
-
-            DBCommand plugin;
-            string cleanMessage = "";
-
-            if (message.HasMentionPrefix(client.CurrentUser, ref argPos))
-            {
-                string mentionPrefix = "<@" + client.CurrentUser.Id + ">";
-
-                plugin = PluginLoader.Commands!
-                    .FirstOrDefault(plug => plug.Command == message.Content.Substring(mentionPrefix.Length+1).Split(' ')[0] ||
-                                            (
-                                                plug.Aliases is not null &&
-                                                plug.Aliases.Contains(message.CleanContent.Substring(mentionPrefix.Length+1).Split(' ')[0])
-                                            ));
-
-                cleanMessage = message.Content.Substring(mentionPrefix.Length + 1);
-            }
-
-            else
-            {
-                plugin = PluginLoader.Commands!
-                    .FirstOrDefault(p => p.Command == message.Content.Split(' ')[0].Substring(botPrefix.Length) ||
-                                         (p.Aliases is not null &&
-                                          p.Aliases.Contains(
-                                              message.Content.Split(' ')[0].Substring(botPrefix.Length))));
-                cleanMessage = message.Content.Substring(botPrefix.Length);
-            }
-            if (plugin is null) 
-                throw new Exception($"Failed to run command ! " + message.CleanContent + " (user: " + context.Message.Author.Username + " - " + context.Message.Author.Id + ")");
-
-            if (plugin.requireAdmin && !context.Message.Author.isAdmin())
-                return;
-
-            string[] split = cleanMessage.Split(' ');
-
-            string[] argsClean = null;
-            if(split.Length > 1)
-                argsClean = string.Join(' ', split, 1, split.Length-1).Split(' ');
-
-            DBCommandExecutingArguments cmd = new(context, cleanMessage, split[0], argsClean);
-
-            if (context.Channel is SocketDMChannel)
-                plugin.ExecuteDM(cmd);
-            else plugin.ExecuteServer(cmd);
-        }
-        catch (Exception ex)
-        {
-            Config.Logger.Log(ex.Message, this, LogLevel.ERROR);
-        }
-    }
-}

PluginManager/Config.cs

@@ -1,167 +1,169 @@
 using System;
-using System.Threading.Tasks;
-using System.IO;
-
-using System.Collections.Generic;
 using PluginManager.Others;
-using System.Collections;
+using System.IO;
-using PluginManager.Online.Helpers;
+using System.Text.Json;
-using PluginManager.Others.Logger;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading;
+using Newtonsoft.Json.Linq;
 
-namespace PluginManager;
+namespace PluginManager
-
-public static class Config
 {
-    private static bool IsLoaded = false;
+    internal class AppConfig
-
-    public static DBLogger Logger;
-    public static Json<string, string> Data;
-    public static Json<string, string> Plugins;
-
-    public static async Task Initialize()
     {
-        if (IsLoaded)
+        public Dictionary<string, object>? ApplicationVariables { get; set; }
-            return;
+        public List<string>?               ProtectedKeyWords    { get; set; }
-
-        Directory.CreateDirectory("./Data/Resources");
-        Directory.CreateDirectory("./Data/Plugins");
-        Directory.CreateDirectory("./Data/PAKS");
-        Directory.CreateDirectory("./Data/Logs/Logs");
-        Directory.CreateDirectory("./Data/Logs/Errors");
-
-        Data = new Json<string, string>("./Data/Resources/config.json");
-        Plugins = new Json<string, string>("./Data/Resources/Plugins.json");
-
-        Config.Data["LogFolder"] = "./Data/Logs/Logs";
-        Config.Data["ErrorFolder"] = "./Data/Logs/Errors";
-
-        Logger = new DBLogger();
-        
-        ArchiveManager.Initialize();
-
-        IsLoaded = true;
-
-        Logger.Log("Config initialized", LogLevel.INFO);
     }
 
-    public class Json<TKey, TValue> : IDictionary<TKey, TValue>
+    public static class Config
     {
-        protected IDictionary<TKey, TValue> _dictionary;
+        public static class PluginConfig
-        private readonly string _file = "";
-        
-        public Json(string file)
         {
-            _dictionary = PrivateReadConfig(file).GetAwaiter().GetResult();
+            public static List<Tuple<string, PluginType>> InstalledPlugins = new();
-            this._file = file;
-        }
 
-        public async void Save()
+            public static void Load()
-        {
-            await Functions.SaveToJsonFile(_file, _dictionary);
-        }
-
-        public virtual void Add(TKey key, TValue value)
-        {
-            _dictionary.Add(key, value);
-        }
-
-        public void Clear() { _dictionary.Clear(); }
-
-        public bool ContainsKey(TKey key)
-        {
-            if (_dictionary == null)
-                throw new Exception("Dictionary is null");
-
-            return _dictionary.ContainsKey(key);
-        }
-
-        public virtual ICollection<TKey> Keys => _dictionary.Keys;
-
-        public virtual ICollection<TValue> Values => _dictionary.Values;
-
-        public int Count => _dictionary.Count;
-
-        public bool IsReadOnly => _dictionary.IsReadOnly;
-
-        public virtual TValue this[TKey key]
-        {
-            get
             {
-                if (_dictionary.TryGetValue(key, out TValue value)) return value;
+                new Thread(LoadCommands).Start();
-                throw new Exception("Key not found in dictionary " + key.ToString() + " (Json )" + this.GetType().Name + ")");
+                new Thread(LoadEvents).Start();
-
             }
-            set
+
+            private static void LoadCommands()
             {
-                if (_dictionary.ContainsKey(key))
+                string   cmd_path = "./Data/Plugins/Commands/";
-                    _dictionary[key] = value;
+                string[] files    = Directory.GetFiles(cmd_path, $"*.{Loaders.PluginLoader.pluginCMDExtension}", SearchOption.AllDirectories);
-                else _dictionary.Add(key, value);
+                foreach (var file in files)
+                    if (!file.Contains("PluginManager", StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        string PluginName = new FileInfo(file).Name;
+                        string name       = PluginName.Substring(0, PluginName.Length - 1 - PluginManager.Loaders.PluginLoader.pluginCMDExtension.Length);
+                        InstalledPlugins.Add(new(name, PluginType.Command));
+                    }
+            }
+
+            private static void LoadEvents()
+            {
+                string   eve_path = "./Data/Plugins/Events/";
+                string[] files    = Directory.GetFiles(eve_path, $"*.{Loaders.PluginLoader.pluginEVEExtension}", SearchOption.AllDirectories);
+                foreach (var file in files)
+                    if (!file.Contains("PluginManager", StringComparison.InvariantCultureIgnoreCase))
+                        if (!file.Contains("PluginManager", StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            string PluginName = new FileInfo(file).Name;
+                            string name       = PluginName.Substring(0, PluginName.Length - 1 - PluginManager.Loaders.PluginLoader.pluginEVEExtension.Length);
+                            InstalledPlugins.Add(new(name, PluginType.Event));
+                        }
+            }
+
+            public static bool Contains(string pluginName)
+            {
+                foreach (var tuple in InstalledPlugins)
+                {
+                    if (tuple.Item1 == pluginName) return true;
+                }
+
+                return false;
+            }
+
+            public static PluginType GetPluginType(string pluginName)
+            {
+                foreach (var tuple in InstalledPlugins)
+                {
+                    if (tuple.Item1 == pluginName) return tuple.Item2;
+                }
+
+                return PluginType.Unknown;
             }
         }
 
-        public virtual bool TryGetValue(TKey key, out TValue value)
+        private static AppConfig? appConfig { get; set; }
+
+        public static bool AddValueToVariables<T>(string key, T value, bool isProtected)
         {
-            return _dictionary.TryGetValue(key, out value);
+            if (appConfig!.ApplicationVariables!.ContainsKey(key)) return false;
+            if (value == null) return false;
+            appConfig.ApplicationVariables.Add(key, value);
+            if (isProtected && key != "Version") appConfig.ProtectedKeyWords!.Add(key);
+
+            SaveConfig();
+            return true;
         }
 
-        private async Task<Dictionary<TKey, TValue>> PrivateReadConfig(string file)
+        public static void GetAndAddValueToVariable(string key, string value, bool isReadOnly)
         {
-            if (!File.Exists(file))
+            if (Config.ContainsKey(key)) return;
-            {
+            if (int.TryParse(value, out var intValue))
-                var dictionary = new Dictionary<TKey, TValue>();
+                Config.AddValueToVariables(key, intValue, isReadOnly);
-                await Functions.SaveToJsonFile(file, _dictionary);
+            else if (bool.TryParse(value, out var boolValue))
-                return dictionary;
+                Config.AddValueToVariables(key, boolValue, isReadOnly);
-            }
+            else if (float.TryParse(value, out var floatValue))
+                Config.AddValueToVariables(key, floatValue, isReadOnly);
+            else if (double.TryParse(value, out var doubleValue))
+                Config.AddValueToVariables(key, doubleValue, isReadOnly);
+            else if (uint.TryParse(value, out var uintValue))
+                Config.AddValueToVariables(key, uintValue, isReadOnly);
+            else if (long.TryParse(value, out var longValue))
+                Config.AddValueToVariables(key, longValue, isReadOnly);
+            else if (byte.TryParse(value, out var byteValue))
+                Config.AddValueToVariables(key, byteValue, isReadOnly);
+            else
+                Config.AddValueToVariables(key, value, isReadOnly);
+        }
 
+        public static T? GetValue<T>(string key)
+        {
+            if (!appConfig!.ApplicationVariables!.ContainsKey(key)) return default;
             try
             {
-                var d = await Functions.ConvertFromJson<Dictionary<TKey, TValue>>(file);
+                JsonElement element = (JsonElement)appConfig.ApplicationVariables[key];
-                if (d is null)
+                return element.Deserialize<T>();
-                    throw new Exception("Failed to read config file");
+            }
-                
+            catch
-                return d;
+            {
-            }catch (Exception ex)
+                return (T)appConfig.ApplicationVariables[key];
-            {
-                File.Delete(file);
-                return new Dictionary<TKey, TValue>();
             }
-
         }
 
-        public bool Remove(TKey key)
+        public static bool SetValue<T>(string key, T value)
         {
-            return _dictionary.Remove(key);
+            if (!appConfig!.ApplicationVariables!.ContainsKey(key)) return false;
+            if (appConfig.ProtectedKeyWords!.Contains(key)) return false;
+            if (value == null) return false;
+
+            appConfig.ApplicationVariables[key] = JsonSerializer.SerializeToElement(value);
+            SaveConfig();
+            return true;
         }
 
-        public void Add(KeyValuePair<TKey, TValue> item)
+        public static bool RemoveKey(string key)
         {
-            _dictionary.Add(item);
+            if (key == "Version" || key == "token" || key == "prefix") return false;
+            appConfig!.ApplicationVariables!.Remove(key);
+            appConfig.ProtectedKeyWords!.Remove(key);
+            SaveConfig();
+            return true;
         }
 
-        public bool Contains(KeyValuePair<TKey, TValue> item)
+        public static async void SaveConfig()
         {
-            return _dictionary.Contains(item);
+            string path = Functions.dataFolder + "config.json";
+            await Functions.SaveToJsonFile<AppConfig>(path, appConfig!);
         }
 
-        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
+        public static async Task LoadConfig()
         {
-            _dictionary.CopyTo(array, arrayIndex);
+            string path = Functions.dataFolder + "config.json";
+            if (File.Exists(path))
+            {
+                appConfig = await Functions.ConvertFromJson<AppConfig>(path);
+                Functions.WriteLogFile($"Loaded {appConfig.ApplicationVariables!.Keys.Count} application variables.\nLoaded {appConfig.ProtectedKeyWords!.Count} readonly variables.");
+            }
+            else
+                appConfig = new() { ApplicationVariables = new Dictionary<string, object>(), ProtectedKeyWords = new List<string>() };
         }
 
-        public bool Remove(KeyValuePair<TKey, TValue> item)
+        public static bool ContainsValue<T>(T value) => appConfig!.ApplicationVariables!.ContainsValue(value!);
-        {
+        public static bool ContainsKey(string key)   => appConfig!.ApplicationVariables!.ContainsKey(key);
-            return _dictionary.Remove(item);
-        }
 
-        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        public static Dictionary<string, object> GetAllVariables() => new(appConfig!.ApplicationVariables!);
-        {
-            return _dictionary.GetEnumerator();
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return ((IEnumerable)_dictionary).GetEnumerator();
-        }
     }
-
 }

PluginManager/Database/SqlDatabase.cs

@@ -1,489 +0,0 @@
-using System.Collections.Generic;
-using System.Data.SQLite;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace PluginManager.Database
-{
-    public class SqlDatabase
-    {
-        private string ConnectionString;
-        private SQLiteConnection Connection;
-
-        /// <summary>
-        /// Initialize a SQL connection by specifing its private path
-        /// </summary>
-        /// <param name="fileName">The path to the database (it is starting from ./Data/Resources/)</param>
-        public SqlDatabase(string fileName)
-        {
-            if (!fileName.StartsWith("./Data/Resources/"))
-                fileName = Path.Combine("./Data/Resources", fileName);
-            if (!File.Exists(fileName))
-                SQLiteConnection.CreateFile(fileName);
-            ConnectionString = $"URI=file:{fileName}";
-            Connection = new SQLiteConnection(ConnectionString);
-        }
-
-
-        /// <summary>
-        /// Open the SQL Connection. To close use the Stop() method
-        /// </summary>
-        /// <returns></returns>
-        public async Task Open()
-        {
-            await Connection.OpenAsync();
-        }
-
-        /// <summary>
-        /// <para>
-        ///     Insert into a specified table some values
-        /// </para>
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="values">The values to be inserted (in the correct order and number)</param>
-        /// <returns></returns>
-        public async Task InsertAsync(string tableName, params string[] values)
-        {
-            string query = $"INSERT INTO {tableName} VALUES (";
-            for (int i = 0; i < values.Length; i++)
-            {
-                query += $"'{values[i]}'";
-                if (i != values.Length - 1)
-                    query += ", ";
-            }
-
-            query += ")";
-
-            SQLiteCommand command = new SQLiteCommand(query, Connection);
-            await command.ExecuteNonQueryAsync();
-        }
-
-        /// <summary>
-        /// <para>
-        ///     Insert into a specified table some values
-        /// </para>
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="values">The values to be inserted (in the correct order and number)</param>
-        /// <returns></returns>
-        public void Insert(string tableName, params string[] values)
-        {
-            string query = $"INSERT INTO {tableName} VALUES (";
-            for (int i = 0; i < values.Length; i++)
-            {
-                query += $"'{values[i]}'";
-                if (i != values.Length - 1)
-                    query += ", ";
-            }
-
-            query += ")";
-
-            SQLiteCommand command = new SQLiteCommand(query, Connection);
-            command.ExecuteNonQuery();
-        }
-
-        /// <summary>
-        /// Remove every row in a table that has a certain propery
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="KeyName">The column name that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the specified column</param>
-        /// <returns></returns>
-        public async Task RemoveKeyAsync(string tableName, string KeyName, string KeyValue)
-        {
-            string query = $"DELETE FROM {tableName} WHERE {KeyName} = '{KeyValue}'";
-
-            SQLiteCommand command = new SQLiteCommand(query, Connection);
-            await command.ExecuteNonQueryAsync();
-        }
-
-        /// <summary>
-        /// Remove every row in a table that has a certain propery
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="KeyName">The column name that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the specified column</param>
-        /// <returns></returns>
-        public void RemoveKey(string tableName, string KeyName, string KeyValue)
-        {
-            string query = $"DELETE FROM {tableName} WHERE {KeyName} = '{KeyValue}'";
-
-            SQLiteCommand command = new SQLiteCommand(query, Connection);
-            command.ExecuteNonQuery();
-        }
-
-        /// <summary>
-        /// Check if the key exists in the table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="keyName">The column that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the specified column</param>
-        /// <returns></returns>
-        public async Task<bool> KeyExistsAsync(string tableName, string keyName, string KeyValue)
-        {
-            string query = $"SELECT * FROM {tableName} where {keyName} = '{KeyValue}'";
-
-            if (await ReadDataAsync(query) is not null)
-                return true;
-
-            return false;
-        }
-
-        /// <summary>
-        /// Check if the key exists in the table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="keyName">The column that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the specified column</param>
-        /// <returns></returns>
-        public bool KeyExists(string tableName, string keyName, string KeyValue)
-        {
-            string query = $"SELECT * FROM {tableName} where {keyName} = '{KeyValue}'";
-
-            if (ReadData(query) is not null)
-                return true;
-
-            return false;
-        }
-
-        /// <summary>
-        /// Set value of a column in a table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="keyName">The column that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the column specified</param>
-        /// <param name="ResultColumnName">The column that has to be modified</param>
-        /// <param name="ResultColumnValue">The new value that will replace the old value from the column specified</param>
-
-        public async Task SetValueAsync(string tableName, string keyName, string KeyValue, string ResultColumnName,
-                                        string ResultColumnValue)
-        {
-            if (!await TableExistsAsync(tableName))
-                throw new System.Exception($"Table {tableName} does not exist");
-
-            await ExecuteAsync(
-                $"UPDATE {tableName} SET {ResultColumnName}='{ResultColumnValue}' WHERE {keyName}='{KeyValue}'");
-        }
-
-        /// <summary>
-        /// Set value of a column in a table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="keyName">The column that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the column specified</param>
-        /// <param name="ResultColumnName">The column that has to be modified</param>
-        /// <param name="ResultColumnValue">The new value that will replace the old value from the column specified</param>
-
-        public void SetValue(string tableName, string keyName, string KeyValue, string ResultColumnName,
-                             string ResultColumnValue)
-        {
-            if (!TableExists(tableName))
-                throw new System.Exception($"Table {tableName} does not exist");
-
-            Execute($"UPDATE {tableName} SET {ResultColumnName}='{ResultColumnValue}' WHERE {keyName}='{KeyValue}'");
-        }
-
-        /// <summary>
-        /// Get value from a column in a table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="keyName">The column that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the specified column</param>
-        /// <param name="ResultColumnName">The column that has the result</param>
-        /// <returns>A string that has the requested value (can be null if nothing found)</returns>
-        public async Task<string?> GetValueAsync(string tableName, string keyName, string KeyValue,
-                                                string ResultColumnName)
-        {
-            if (!await TableExistsAsync(tableName))
-                throw new System.Exception($"Table {tableName} does not exist");
-
-            return await ReadDataAsync($"SELECT {ResultColumnName} FROM {tableName} WHERE {keyName}='{KeyValue}'");
-        }
-
-        /// <summary>
-        /// Get value from a column in a table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="keyName">The column that the search is made by</param>
-        /// <param name="KeyValue">The value that is searched in the specified column</param>
-        /// <param name="ResultColumnName">The column that has the result</param>
-        /// <returns>A string that has the requested value (can be null if nothing found)</returns>
-
-        public string? GetValue(string tableName, string keyName, string KeyValue, string ResultColumnName)
-        {
-            if (!TableExists(tableName))
-                throw new System.Exception($"Table {tableName} does not exist");
-
-            return ReadData($"SELECT {ResultColumnName} FROM {tableName} WHERE {keyName}='{KeyValue}'");
-        }
-        
-        /// <summary>
-        /// Stop the connection to the SQL Database
-        /// </summary>
-        /// <returns></returns>
-        public async void Stop()
-        {
-            await Connection.CloseAsync();
-        }
-
-        /// <summary>
-        /// Change the structure of a table by adding new columns
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="columns">The columns to be added</param>
-        /// <param name="TYPE">The type of the columns (TEXT, INTEGER,  FLOAT, etc)</param>
-        /// <returns></returns>
-        public async Task AddColumnsToTableAsync(string tableName, string[] columns, string TYPE = "TEXT")
-        {
-            var command = Connection.CreateCommand();
-            command.CommandText = $"SELECT * FROM {tableName}";
-            var reader = await command.ExecuteReaderAsync();
-            var tableColumns = new List<string>();
-            for (int i = 0; i < reader.FieldCount; i++)
-                tableColumns.Add(reader.GetName(i));
-
-            foreach (var column in columns)
-            {
-                if (!tableColumns.Contains(column))
-                {
-                    command.CommandText = $"ALTER TABLE {tableName} ADD COLUMN {column} {TYPE}";
-                    await command.ExecuteNonQueryAsync();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Change the structure of a table by adding new columns
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="columns">The columns to be added</param>
-        /// <param name="TYPE">The type of the columns (TEXT, INTEGER,  FLOAT, etc)</param>
-        /// <returns></returns>
-
-        public void AddColumnsToTable(string tableName, string[] columns, string TYPE = "TEXT")
-        {
-            var command = Connection.CreateCommand();
-            command.CommandText = $"SELECT * FROM {tableName}";
-            var reader = command.ExecuteReader();
-            var tableColumns = new List<string>();
-            for (int i = 0; i < reader.FieldCount; i++)
-                tableColumns.Add(reader.GetName(i));
-
-            foreach (var column in columns)
-            {
-                if (!tableColumns.Contains(column))
-                {
-                    command.CommandText = $"ALTER TABLE {tableName} ADD COLUMN {column} {TYPE}";
-                    command.ExecuteNonQuery();
-                }
-            }
-        }
-
-        /// <summary>
-        /// Check if a table exists
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <returns>True if the table exists, false if not</returns>
-        public async Task<bool> TableExistsAsync(string tableName)
-        {
-            var cmd = Connection.CreateCommand();
-            cmd.CommandText = $"SELECT name FROM sqlite_master WHERE type='table' AND name='{tableName}'";
-            var result = await cmd.ExecuteScalarAsync();
-
-            if (result == null)
-                return false;
-            return true;
-        }
-
-        /// <summary>
-        /// Check if a table exists
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <returns>True if the table exists, false if not</returns>
-        public bool TableExists(string tableName)
-        {
-            var cmd = Connection.CreateCommand();
-            cmd.CommandText = $"SELECT name FROM sqlite_master WHERE type='table' AND name='{tableName}'";
-            var result = cmd.ExecuteScalar();
-
-            if (result == null)
-                return false;
-            return true;
-        }
-
-        /// <summary>
-        /// Create a table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="columns">The columns of the table</param>
-        /// <returns></returns>
-
-        public async Task CreateTableAsync(string tableName, params string[] columns)
-        {
-            var cmd = Connection.CreateCommand();
-            cmd.CommandText = $"CREATE TABLE IF NOT EXISTS {tableName} ({string.Join(", ", columns)})";
-            await cmd.ExecuteNonQueryAsync();
-        }
-
-        /// <summary>
-        /// Create a table
-        /// </summary>
-        /// <param name="tableName">The table name</param>
-        /// <param name="columns">The columns of the table</param>
-        /// <returns></returns>
-
-        public void CreateTable(string tableName, params string[] columns)
-        {
-            var cmd = Connection.CreateCommand();
-            cmd.CommandText = $"CREATE TABLE IF NOT EXISTS {tableName} ({string.Join(", ", columns)})";
-            cmd.ExecuteNonQuery();
-        }
-
-        /// <summary>
-        /// Execute a custom query
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>The number of rows that the query modified</returns>
-        public async Task<int> ExecuteAsync(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                await Connection.OpenAsync();
-            var command = new SQLiteCommand(query, Connection);
-            int answer = await command.ExecuteNonQueryAsync();
-            return answer;
-        }
-
-        /// <summary>
-        /// Execute a custom query
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>The number of rows that the query modified</returns>
-        public int Execute(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                Connection.Open();
-            var command = new SQLiteCommand(query, Connection);
-            int r = command.ExecuteNonQuery();
-
-            return r;
-        }
-
-        /// <summary>
-        /// Read data from the result table and return the first row
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>The result is a string that has all values separated by space character</returns>
-        public async Task<string?> ReadDataAsync(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                await Connection.OpenAsync();
-            var command = new SQLiteCommand(query, Connection);
-            var reader = await command.ExecuteReaderAsync();
-
-            object[] values = new object[reader.FieldCount];
-            if (reader.Read())
-            {
-                reader.GetValues(values);
-                return string.Join<object>(" ", values);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Read data from the result table and return the first row
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>The result is a string that has all values separated by space character</returns>
-        public string? ReadData(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                Connection.Open();
-            var command = new SQLiteCommand(query, Connection);
-            var reader = command.ExecuteReader();
-
-            object[] values = new object[reader.FieldCount];
-            if (reader.Read())
-            {
-                reader.GetValues(values);
-                return string.Join<object>(" ", values);
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        ///    Read data from the result table and return the first row
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>The first row as separated items</returns>
-        public async Task<object[]?> ReadDataArrayAsync(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                await Connection.OpenAsync();
-            var command = new SQLiteCommand(query, Connection);
-            var reader = await command.ExecuteReaderAsync();
-
-            object[] values = new object[reader.FieldCount];
-            if (reader.Read())
-            {
-                reader.GetValues(values);
-                return values;
-            }
-
-            return null;
-        }
-
-
-        /// <summary>
-        ///    Read data from the result table and return the first row
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>The first row as separated items</returns>
-        public object[]? ReadDataArray(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                Connection.Open();
-            var command = new SQLiteCommand(query, Connection);
-            var reader = command.ExecuteReader();
-
-            object[] values = new object[reader.FieldCount];
-            if (reader.Read())
-            {
-                reader.GetValues(values);
-                return values;
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// Read all rows from the result table and return them as a list of string arrays. The string arrays contain the values of each row
-        /// </summary>
-        /// <param name="query">The query</param>
-        /// <returns>A list of string arrays representing the values that the query returns</returns>
-
-        public async Task<List<string[]>?> ReadAllRowsAsync(string query)
-        {
-            if (!Connection.State.HasFlag(System.Data.ConnectionState.Open))
-                await Connection.OpenAsync();
-            var command = new SQLiteCommand(query, Connection);
-            var reader = await command.ExecuteReaderAsync();
-
-            if (!reader.HasRows)
-                return null;
-
-            List<string[]> rows = new();
-            while (await reader.ReadAsync())
-            {
-                string[] values = new string[reader.FieldCount];
-                reader.GetValues(values);
-                rows.Add(values);
-            }
-
-            if (rows.Count == 0) return null;
-
-            return rows;
-        }
-    }
-}

PluginManager/Interfaces/DBCommand.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
+using Discord.Commands;
-using PluginManager.Others;
+using Discord.WebSocket;
 
 namespace PluginManager.Interfaces;
 
@@ -11,11 +11,6 @@ public interface DBCommand
     /// </summary>
     string Command { get; }
 
-    /// <summary>
-    ///     Command aliases. Users may use this to execute the command
-    /// </summary>
-    List<string>? Aliases { get; }
-
     /// <summary>
     ///     Command description
     /// </summary>
@@ -27,24 +22,30 @@ public interface DBCommand
     /// </summary>
     string Usage { get; }
 
+    /// <summary>
+    ///     true if the command can be used in a DM channel, otherwise false
+    /// </summary>
+    bool canUseDM { get; }
+
+    /// <summary>
+    ///     true if the command can be used in a server, otherwise false
+    /// </summary>
+    bool canUseServer { get; }
+
     /// <summary>
     ///     true if the command requre admin, otherwise false
     /// </summary>
     bool requireAdmin { get; }
 
     /// <summary>
-    ///     The main body of the command. This is what is executed when user calls the command in Server
+    ///     The main body of the command. This is what is executed when user calls the command
     /// </summary>
-    /// <param name="args">The disocrd Context</param>
+    /// <param name="context">The disocrd Context</param>
-    void ExecuteServer(DBCommandExecutingArguments args)
+    /// <param name="message">The message that the user types</param>
-    {
+    /// <param name="client">The discord client of the bot</param>
-    }
+    /// <param name="isDM">true if the message was sent from DM, otherwise false. It is always false if canUseDM is false</param>
-
+    void Execute(SocketCommandContext context,
-    /// <summary>
+                 SocketMessage        message,
-    ///     The main body of the command. This is what is executed when user calls the command in DM
+                 DiscordSocketClient  client,
-    /// </summary>
+                 bool                 isDM);
-    /// <param name="args">The disocrd Context</param>
+}
-    void ExecuteDM(DBCommandExecutingArguments args)
-    {
-    }
-}

PluginManager/Interfaces/DBEvent.cs

@@ -7,16 +7,16 @@ public interface DBEvent
     /// <summary>
     ///     The name of the event
     /// </summary>
-    string Name { get; }
+    string name { get; }
 
     /// <summary>
     ///     The description of the event
     /// </summary>
-    string Description { get; }
+    string description { get; }
 
     /// <summary>
     ///     The method that is invoked when the event is loaded into memory
     /// </summary>
     /// <param name="client">The discord bot client</param>
     void Start(DiscordSocketClient client);
-}
+}

PluginManager/Interfaces/DBSlashCommand.cs

@@ -1,25 +0,0 @@
-using System.Collections.Generic;
-
-using Discord;
-using Discord.WebSocket;
-
-namespace PluginManager.Interfaces
-{
-    public interface DBSlashCommand
-    {
-        string Name { get; }
-        string Description { get; }
-
-        bool canUseDM { get; }
-
-        List<SlashCommandOptionBuilder> Options { get; }
-
-        void ExecuteServer(SocketSlashCommand context)
-        {
-
-        }
-
-        void ExecuteDM(SocketSlashCommand context) { }
-
-    }
-}

PluginManager/Items/Command.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using Discord.WebSocket;
+using PluginManager.Others;
+
+namespace PluginManager.Items;
+
+internal class Command
+{
+    /// <summary>
+    ///     The author of the command
+    /// </summary>
+    public SocketUser? Author;
+
+    /// <summary>
+    ///     The Command class contructor
+    /// </summary>
+    /// <param name="message">The message that was sent</param>
+    public Command(SocketMessage message)
+    {
+        Author = message.Author;
+        var data = message.Content.Split(' ');
+        if (data.Length > 1)
+            Arguments = new List<string>(data.MergeStrings(1).Split(' '));
+        else
+            Arguments = new List<string>();
+        CommandName = data[0].Substring(1);
+        PrefixUsed  = data[0][0];
+    }
+
+    /// <summary>
+    ///     The list of arguments
+    /// </summary>
+    public List<string> Arguments { get; }
+
+    /// <summary>
+    ///     The command that is executed
+    /// </summary>
+    public string CommandName { get; }
+
+    /// <summary>
+    ///     The prefix that is used for the command
+    /// </summary>
+    public char PrefixUsed { get; }
+}
+
+public class ConsoleCommand
+{
+        public string CommandName { get; set; }
+        public string Description { get; set; }
+        public string Usage { get; set; }
+        public Action<string[]> Action { get; set; }
+}

PluginManager/Items/ConsoleCommandsHandler.cs

@@ -0,0 +1,310 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Discord.WebSocket;
+using PluginManager.Loaders;
+using PluginManager.Online;
+using PluginManager.Others;
+
+namespace PluginManager.Items;
+
+public class ConsoleCommandsHandler
+{
+    private static readonly PluginsManager       manager     = new("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/Plugins.txt");
+    public static           List<ConsoleCommand> commandList = new();
+    private readonly        DiscordSocketClient? client;
+
+    public ConsoleCommandsHandler(DiscordSocketClient client)
+    {
+        this.client = client;
+        InitializeBasicCommands();
+        Console.WriteLine("Initialized console command handler !");
+    }
+
+    private void InitializeBasicCommands()
+    {
+        var pluginsLoaded = false;
+        commandList.Clear();
+
+        AddCommand("help", "Show help", "help <command>", args =>
+            {
+                if (args.Length <= 1)
+                {
+                    Console.WriteLine("Available commands:");
+                    List<string[]> items = new List<string[]>();
+                    items.Add(new[] { "-", "-", "-" });
+                    items.Add(new[] { "Command", "Description", "Usage" });
+                    items.Add(new[] { " ", " ", "Argument type: <optional> [required]" });
+                    items.Add(new[] { "-", "-", "-" });
+
+                    foreach (var command in commandList)
+                    {
+                        var pa = from p in command.Action.Method.GetParameters()
+                                 where p.Name != null
+                                 select p.ParameterType.FullName;
+                        items.Add(new[] { command.CommandName, command.Description, command.Usage });
+                    }
+
+                    items.Add(new[] { "-", "-", "-" });
+                    Console_Utilities.FormatAndAlignTable(items);
+                }
+                else
+                {
+                    foreach (var command in commandList)
+                        if (command.CommandName == args[1])
+                        {
+                            Console.WriteLine("Command description: " + command.Description);
+                            Console.WriteLine("Command execution format:" + command.Usage);
+                            return;
+                        }
+
+                    Console.WriteLine("Command not found");
+                }
+            }
+        );
+
+
+        AddCommand("lp", "Load plugins", () =>
+            {
+                if (pluginsLoaded) return;
+                var loader = new PluginLoader(client!);
+                loader.onCMDLoad += (name, typeName, success, exception) =>
+                {
+                    Console.ForegroundColor = ConsoleColor.Green;
+                    if (name == null || name.Length < 2) name = typeName;
+                    if (success)
+                        Console.WriteLine("[CMD] Successfully loaded command : " + name);
+                    else
+                        Console.WriteLine("[CMD] Failed to load command : " + name + " because " + exception!.Message);
+                    Console.ForegroundColor = ConsoleColor.Red;
+                };
+                loader.onEVELoad += (name, typeName, success, exception) =>
+                {
+                    if (name == null || name.Length < 2) name = typeName;
+                    Console.ForegroundColor = ConsoleColor.Green;
+                    if (success)
+                        Console.WriteLine("[EVENT] Successfully loaded event : " + name);
+                    else
+                        Console.WriteLine("[EVENT] Failed to load event : " + name + " because " + exception!.Message);
+                    Console.ForegroundColor = ConsoleColor.Red;
+                };
+                loader.LoadPlugins();
+                pluginsLoaded = true;
+            }
+        );
+
+        AddCommand("listplugs", "list available plugins", async () => { await manager.ListAvailablePlugins(); });
+
+        AddCommand("dwplug", "download plugin", "dwplug [name]", async args =>
+            {
+                if (args.Length == 1)
+                {
+                    Console.WriteLine("Please specify plugin name");
+                    return;
+                }
+
+                var name = args.MergeStrings(1);
+                // info[0] = plugin type
+                // info[1] = plugin link
+                // info[2] = if others are required, or string.Empty if none
+                var info = await manager.GetPluginLinkByName(name);
+                if (info[1] == null) // link is null
+                {
+                    if (name == "")
+                    {
+                        Console_Utilities.WriteColorText("Name is invalid");
+                        return;
+                    }
+
+                    Console_Utilities.WriteColorText($"Failed to find plugin &b{name} &c!" +
+                                                     " Use &glistplugs &ccommand to display all available plugins !"
+                    );
+                    return;
+                }
+
+                string path;
+                if (info[0] == "Command" || info[0] == "Event")
+                    path = "./Data/Plugins/" + info[0] + "s/" + name + ".dll";
+                else
+                    path = $"./{info[1].Split('/')[info[1].Split('/').Length - 1]}";
+                await ServerCom.DownloadFileAsync(info[1], path);
+                if (info[0] == "Command" || info[0] == "Event")
+                    if (info[0] == "Event")
+                        Config.PluginConfig.InstalledPlugins.Add(new(name, PluginType.Event));
+                    else if (info[0] == "Command") Config.PluginConfig.InstalledPlugins.Add(new(name, PluginType.Command));
+
+
+                Console.WriteLine("\n");
+
+                // check requirements if any
+
+                if (info.Length == 3 && info[2] != string.Empty && info[2] != null)
+                {
+                    Console.WriteLine($"Downloading requirements for plugin : {name}");
+
+                    var lines = await ServerCom.ReadTextFromFile(info[2]);
+
+                    foreach (var line in lines)
+                    {
+                        if (!(line.Length > 0 && line.Contains(","))) continue;
+                        var split = line.Split(',');
+                        Console.WriteLine($"\nDownloading item: {split[1]}");
+                        await ServerCom.DownloadFileAsync(split[0], "./" + split[1]);
+                        Console.WriteLine();
+
+                        if (split[0].EndsWith(".zip"))
+                        {
+                            Console.WriteLine($"Extracting {split[1]}");
+                            var proc         = 0d;
+                            var isExtracting = true;
+                            var bar          = new Console_Utilities.ProgressBar { Max = 100, Color = ConsoleColor.Green };
+
+                            IProgress<float> extractProgress = new Progress<float>(value => { proc = value; });
+                            new Thread(new Task(() =>
+                                           {
+                                               while (isExtracting)
+                                               {
+                                                   bar.Update((int)proc);
+                                                   if (proc >= 99.9f) break;
+                                                   Thread.Sleep(500);
+                                               }
+                                           }
+                                       ).Start
+                            ).Start();
+                            await Functions.ExtractArchive("./" + split[1], "./", extractProgress);
+                            bar.Update(100);
+                            isExtracting = false;
+                            await Task.Delay(1000);
+                            bar.Update(100);
+                            Console.WriteLine("\n");
+                            File.Delete("./" + split[1]);
+                        }
+                    }
+
+                    Console.WriteLine();
+                }
+            }
+        );
+
+
+        AddCommand("value", "read value from VariableStack", "value [key]",args =>
+            {
+                if (args.Length != 2) return;
+                if (!Config.ContainsKey(args[1])) return;
+
+                var data = Config.GetValue<string>(args[1]);
+                Console.WriteLine($"{args[1]} => {data}");
+            }
+        );
+
+        AddCommand("add", "add variable to the system variables","add [key] [value] [isReadOnly=true/false]", args =>
+            {
+                if (args.Length < 4) return;
+                var key        = args[1];
+                var value      = args[2];
+                var isReadOnly = args[3].Equals("true", StringComparison.CurrentCultureIgnoreCase);
+
+                try
+                {
+                    Config.GetAndAddValueToVariable(key, value, isReadOnly);
+                    Console.WriteLine($"Updated config file with the following command: {args[1]} => {value}");
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine(ex.ToString());
+                }
+            }
+        );
+
+        AddCommand("remv", "remove variable from system variables", "remv [key]", args =>
+            {
+                if (args.Length < 2) return;
+                Config.RemoveKey(args[1]);
+            }
+        );
+
+        AddCommand("vars", "Display all variables", () =>
+            {
+                var d    = Config.GetAllVariables();
+                var data = new List<string[]>();
+                data.Add(new[] { "-", "-" });
+                data.Add(new[] { "Key", "Value" });
+                data.Add(new[] { "-", "-" });
+                foreach (var kvp in d) data.Add(new[] { kvp.Key, kvp.Value.ToString()! });
+                data.Add(new[] { "-", "-" });
+                Console_Utilities.FormatAndAlignTable(data);
+            }
+        );
+
+        AddCommand("sd", "Shuts down the discord bot", async () =>
+            {
+                if (client is null) return;
+                await client.StopAsync();
+                await client.DisposeAsync();
+                Config.SaveConfig();
+                Environment.Exit(0);
+            }
+        );
+        //Sort the commands by name
+        commandList.Sort((x, y) => x.CommandName.CompareTo(y.CommandName));
+    }
+
+    public static void AddCommand(string command, string description, string usage, Action<string[]> action)
+    {
+        commandList.Add(new ConsoleCommand
+        {
+            CommandName = command,
+            Description = description,
+            Action      = action,
+            Usage       = usage
+        });
+        Console.ForegroundColor = ConsoleColor.White;
+        Console_Utilities.WriteColorText($"Command &r{command} &cadded to the list of commands");
+    }
+
+    public static void AddCommand(string command, string description, Action action)
+    {
+        AddCommand(command, description, command, args => action());
+    }
+
+    public static void RemoveCommand(string command)
+    {
+        commandList.RemoveAll(x => x.CommandName == command);
+    }
+
+    public static bool CommandExists(string command)
+    {
+        return !(GetCommand(command) is null);
+    }
+
+    public static ConsoleCommand? GetCommand(string command)
+    {
+        return commandList.FirstOrDefault(t => t.CommandName == command);
+    }
+
+    public bool HandleCommand(string command, bool removeCommandExecution = true)
+    {
+        var args = command.Split(' ');
+        foreach (var item in commandList.ToList())
+            if (item.CommandName == args[0])
+            {
+                if (removeCommandExecution)
+                {
+                    Console.SetCursorPosition(0, Console.CursorTop - 1);
+                    for (int i = 0; i < command.Length; i++) Console.Write(" ");
+                    Console.SetCursorPosition(0, Console.CursorTop);
+                }
+
+                Console.WriteLine();
+                item.Action(args);
+                return true;
+            }
+
+        return false;
+        //Console.WriteLine($"Executing: {args[0]} with the following parameters: {args.MergeStrings(1)}");
+    }
+}

PluginManager/Loaders/Loader.cs

@@ -1,142 +1,108 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using PluginManager.Others;
 
-using PluginManager.Interfaces;
+namespace PluginManager.Loaders;
 
-namespace PluginManager.Loaders
+internal class LoaderArgs : EventArgs
 {
-    internal class LoaderArgs : EventArgs
+    internal string?    PluginName { get; init; }
+    internal string?    TypeName   { get; init; }
+    internal bool       IsLoaded   { get; init; }
+    internal Exception? Exception  { get; init; }
+    internal object?    Plugin     { get; init; }
+}
+
+internal class Loader<T>
+{
+    internal Loader(string path, string extension)
     {
-        internal string? PluginName { get; init; }
+        this.path      = path;
-        internal string? TypeName { get; init; }
+        this.extension = extension;
-        internal bool IsLoaded { get; init; }
-        internal Exception? Exception { get; init; }
-        internal object? Plugin { get; init; }
     }
-    internal class Loader
+
+
+    private string path      { get; }
+    private string extension { get; }
+
+
+    internal delegate void FileLoadedEventHandler(LoaderArgs args);
+
+    internal delegate void PluginLoadedEventHandler(LoaderArgs args);
+
+    internal event FileLoadedEventHandler? FileLoaded;
+
+    internal event PluginLoadedEventHandler? PluginLoaded;
+
+    internal List<T>? Load()
     {
-        internal Loader(string path, string extension)
+        var list = new List<T>();
+        if (!Directory.Exists(path))
         {
-            this.path = path;
+            Directory.CreateDirectory(path);
-            this.extension = extension;
-        }
-
-
-        private string path { get; }
-        private string extension { get; }
-
-        internal event FileLoadedEventHandler? FileLoaded;
-
-        internal event PluginLoadedEventHandler? PluginLoaded;
-
-
-        internal delegate void FileLoadedEventHandler(LoaderArgs args);
-
-        internal delegate void PluginLoadedEventHandler(LoaderArgs args);
-
-
-        internal (List<DBEvent>?, List<DBCommand>?, List<DBSlashCommand>?) Load()
-        {
-
-            List<DBEvent> events = new();
-            List<DBSlashCommand> slashCommands = new();
-            List<DBCommand> commands = new();
-
-            if (!Directory.Exists(path))
-            {
-                Directory.CreateDirectory(path);
-                return (null, null, null);
-            }
-
-            var files = Directory.GetFiles(path, $"*.{extension}", SearchOption.AllDirectories);
-            foreach (var file in files)
-            {
-                try
-                {
-                    Assembly.LoadFrom(file);
-                }
-                catch (Exception ex)
-                {
-                    Config.Logger.Log("PluginName: " + new FileInfo(file).Name.Split('.')[0] + " not loaded", this, Others.LogLevel.ERROR);
-                    continue;
-                }
-                if (FileLoaded != null)
-                {
-                    var args = new LoaderArgs
-                    {
-                        Exception = null,
-                        TypeName = null,
-                        IsLoaded = false,
-                        PluginName = new FileInfo(file).Name.Split('.')[0],
-                        Plugin = null
-                    };
-                    FileLoaded.Invoke(args);
-                }
-            }
-
-
-
-            return (LoadItems<DBEvent>(), LoadItems<DBCommand>(), LoadItems<DBSlashCommand>());
-        }
-
-        internal List<T> LoadItems<T>()
-        {
-            List<T> list = new();
-
-
-            try
-            {
-                var interfaceType = typeof(T);
-                var types = AppDomain.CurrentDomain.GetAssemblies()
-                                     .SelectMany(a => a.GetTypes())
-                                     .Where(p => interfaceType.IsAssignableFrom(p) && p.IsClass)
-                                     .ToArray();
-
-
-                list.Clear();
-                foreach (var type in types)
-                    try
-                    {
-                        var plugin = (T)Activator.CreateInstance(type)!;
-                        list.Add(plugin);
-
-
-                        if (PluginLoaded != null)
-                            PluginLoaded.Invoke(new LoaderArgs
-                            {
-                                Exception = null,
-                                IsLoaded = true,
-                                PluginName = type.FullName,
-                                TypeName = typeof(T) == typeof(DBCommand) ? "DBCommand" : typeof(T) == typeof(DBEvent) ? "DBEvent" : "DBSlashCommand",
-                                Plugin = plugin
-                            }
-                            );
-                    }
-                    catch (Exception ex)
-                    {
-                        if (PluginLoaded != null)
-                            PluginLoaded.Invoke(new LoaderArgs
-                            {
-                                Exception = ex,
-                                IsLoaded = false,
-                                PluginName = type.FullName,
-                                TypeName = nameof(T)
-                            });
-                    }
-
-                return list;
-            }
-            catch (Exception ex)
-            {
-                Config.Logger.Log(ex.Message, this, Others.LogLevel.ERROR);
-
-                return null;
-            }
             return null;
         }
 
+        var files = Directory.GetFiles(path, $"*.{extension}", SearchOption.AllDirectories);
+        foreach (var file in files)
+        {
+            Assembly.LoadFrom(file);
+            if (FileLoaded != null)
+            {
+                var args = new LoaderArgs
+                {
+                    Exception  = null,
+                    TypeName   = nameof(T),
+                    IsLoaded   = false,
+                    PluginName = file,
+                    Plugin     = null
+                };
+                FileLoaded.Invoke(args);
+            }
+        }
+
+        try
+        {
+            var interfaceType = typeof(T);
+            var types = AppDomain.CurrentDomain.GetAssemblies()
+                                 .SelectMany(a => a.GetTypes())
+                                 .Where(p => interfaceType.IsAssignableFrom(p) && p.IsClass)
+                                 .ToArray();
+
+
+            list.Clear();
+            foreach (var type in types)
+                try
+                {
+                    var plugin = (T)Activator.CreateInstance(type)!;
+                    list.Add(plugin);
+
+
+                    if (PluginLoaded != null)
+                        PluginLoaded.Invoke(new LoaderArgs
+                            {
+                                Exception  = null,
+                                IsLoaded   = true,
+                                PluginName = type.FullName,
+                                TypeName   = nameof(T),
+                                Plugin     = plugin
+                            }
+                        );
+                }
+                catch (Exception ex)
+                {
+                    if (PluginLoaded != null) PluginLoaded.Invoke(new LoaderArgs { Exception = ex, IsLoaded = false, PluginName = type.FullName, TypeName = nameof(T) });
+                }
+        }
+        catch (Exception ex)
+        {
+            Functions.WriteErrFile(ex.ToString());
+        }
+
+
+        return list;
     }
 }

PluginManager/Loaders/PluginLoader.cs

@@ -1,14 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
-using System.Reflection;
-using System.Threading.Tasks;
-
-using Discord;
 using Discord.WebSocket;
-
 using PluginManager.Interfaces;
-using PluginManager.Online;
+using PluginManager.Others;
 
 namespace PluginManager.Loaders;
 
@@ -18,11 +12,11 @@ public class PluginLoader
 
     public delegate void EVELoaded(string name, string typeName, bool success, Exception? e = null);
 
-    public delegate void SLSHLoaded(string name, string tyypename, bool success, Exception? e = null);
+    private const string pluginCMDFolder = @"./Data/Plugins/Commands/";
+    private const string pluginEVEFolder = @"./Data/Plugins/Events/";
 
-    private const string pluginFolder = @"./Data/Plugins/";
+    internal const   string              pluginCMDExtension = "dll";
-
+    internal const   string              pluginEVEExtension = "dll";
-    internal const string pluginExtension = "dll";
     private readonly DiscordSocketClient _client;
 
     /// <summary>
@@ -35,11 +29,6 @@ public class PluginLoader
     /// </summary>
     public EVELoaded? onEVELoad;
 
-    /// <summary>
-    ///     Event that is fired when a <see cref="DBEvent" /> is successfully loaded into events list
-    /// </summary>
-    public SLSHLoaded? onSLSHLoad;
-
     /// <summary>
     ///     The Plugin Loader constructor
     /// </summary>
@@ -60,113 +49,49 @@ public class PluginLoader
     /// </summary>
     public static List<DBEvent>? Events { get; set; }
 
-    /// <summary>
-    ///     A list of <see cref="DBSlashCommand"/> commands
-    /// </summary>
-    public static List<DBSlashCommand>? SlashCommands { get; set; }
-
-    public static int PluginsLoaded { get {
-        var count = 0;
-        if (Commands is not null)
-            count += Commands.Count;
-        if (Events is not null)
-            count += Events.Count;
-        if (SlashCommands is not null)
-            count += SlashCommands.Count;
-        return count;
-    }}
-
     /// <summary>
     ///     The main mathod that is called to load all events
     /// </summary>
-    public async void LoadPlugins()
+    public void LoadPlugins()
     {
-        //Load all plugins
-
         Commands = new List<DBCommand>();
-        Events = new List<DBEvent>();
+        Events   = new List<DBEvent>();
-        SlashCommands = new List<DBSlashCommand>();
 
-        Config.Logger.Log("Starting plugin loader ... Client: " + _client.CurrentUser.Username, this, Others.LogLevel.INFO);
+        Functions.WriteLogFile("Starting plugin loader ... Client: " + _client.CurrentUser.Username);
+        Console.WriteLine("Loading plugins");
 
-        var loader = new Loader("./Data/Plugins", "dll");
+        var commandsLoader = new Loader<DBCommand>(pluginCMDFolder, pluginCMDExtension);
-        loader.FileLoaded += (args) => Config.Logger.Log($"{args.PluginName} file Loaded", this , Others.LogLevel.INFO);
+        var eventsLoader   = new Loader<DBEvent>(pluginEVEFolder, pluginEVEExtension);
-        loader.PluginLoaded += Loader_PluginLoaded;
+
-        var res = loader.Load();
+        commandsLoader.FileLoaded   += OnCommandFileLoaded;
-        Events = res.Item1;
+        commandsLoader.PluginLoaded += OnCommandLoaded;
-        Commands = res.Item2;
+
-        SlashCommands = res.Item3;
+        eventsLoader.FileLoaded   += EventFileLoaded;
+        eventsLoader.PluginLoaded += OnEventLoaded;
+
+        Commands = commandsLoader.Load();
+        Events   = eventsLoader.Load();
     }
 
-    private async void Loader_PluginLoaded(LoaderArgs args)
+    private void EventFileLoaded(LoaderArgs e)
     {
-
+        if (e.IsLoaded) Functions.WriteLogFile($"[EVENT] Event from file [{e.PluginName}] has been successfully created !");
-        switch (args.TypeName)
-        {
-            case "DBCommand":
-                onCMDLoad?.Invoke(((DBCommand)args.Plugin!).Command, args.TypeName!, args.IsLoaded, args.Exception);
-                break;
-            case "DBEvent":
-                try
-                {
-                    if (args.IsLoaded)
-                        ((DBEvent)args.Plugin!).Start(_client);
-
-                    onEVELoad?.Invoke(((DBEvent)args.Plugin!).Name, args.TypeName!, args.IsLoaded, args.Exception);
-                }
-                catch (Exception ex)
-                {
-                    Config.Logger.Log(ex.Message, this, Others.LogLevel.ERROR);
-                }
-                break;
-            case "DBSlashCommand":
-                if (args.IsLoaded)
-                {
-                    var slash = (DBSlashCommand)args.Plugin;
-                    SlashCommandBuilder builder = new SlashCommandBuilder();
-                    builder.WithName(slash.Name);
-                    builder.WithDescription(slash.Description);
-                    builder.WithDMPermission(slash.canUseDM);
-                    builder.Options = slash.Options;
-
-                    onSLSHLoad?.Invoke(((DBSlashCommand)args.Plugin!).Name, args.TypeName, args.IsLoaded, args.Exception);
-                    await _client.CreateGlobalApplicationCommandAsync(builder.Build());
-
-
-                }
-                break;
-        }
     }
-    public static async Task LoadPluginFromAssembly(Assembly asmb, DiscordSocketClient client)
+
+    private void OnCommandFileLoaded(LoaderArgs e)
     {
-        var types = asmb.GetTypes();
+        if (e.IsLoaded) Functions.WriteLogFile($"[CMD] Command from file [{e.PluginName}] has been successfully loaded !");
-        foreach (var type in types)
-            if (type.IsClass && typeof(DBEvent).IsAssignableFrom(type))
-            {
-                var instance = (DBEvent)Activator.CreateInstance(type);
-                instance.Start(client);
-                PluginLoader.Events.Add(instance);
-                Config.Logger.Log($"[EVENT] Loaded external {type.FullName}!", Others.LogLevel.INFO);
-            }
-            else if (type.IsClass && typeof(DBCommand).IsAssignableFrom(type))
-            {
-                var instance = (DBCommand)Activator.CreateInstance(type);
-                PluginLoader.Commands.Add(instance);
-                Config.Logger.Log($"[CMD] Instance: {type.FullName} loaded !", Others.LogLevel.INFO);
-            }
-            else if (type.IsClass && typeof(DBSlashCommand).IsAssignableFrom(type))
-            {
-                var instance = (DBSlashCommand)Activator.CreateInstance(type);
-                SlashCommandBuilder builder = new SlashCommandBuilder();
-                builder.WithName(instance.Name);
-                builder.WithDescription(instance.Description);
-                builder.WithDMPermission(instance.canUseDM);
-                builder.Options = instance.Options;
-
-                await client.CreateGlobalApplicationCommandAsync(builder.Build());
-                PluginLoader.SlashCommands.Add(instance);
-                Config.Logger.Log($"[SLASH] Instance: {type.FullName} loaded !", Others.LogLevel.INFO);
-
-            }
     }
-}
+
+    private void OnEventLoaded(LoaderArgs e)
+    {
+        if (e.IsLoaded) ((DBEvent)e.Plugin!).Start(_client);
+
+        onEVELoad?.Invoke(((DBEvent)e.Plugin!).name, e.TypeName!, e.IsLoaded, e.Exception);
+    }
+
+    private void OnCommandLoaded(LoaderArgs e)
+    {
+        onCMDLoad?.Invoke(((DBCommand)e.Plugin!).Command, e.TypeName!, e.IsLoaded, e.Exception);
+    }
+}

PluginManager/Online/Helpers/OnlineFunctions.cs

@@ -1,67 +1,69 @@
 using System;
-using System.IO;
 using System.Net.Http;
-using System.Threading;
 using System.Threading.Tasks;
-
+using System.IO;
+using System.Threading;
 using PluginManager.Others;
 
-namespace PluginManager.Online.Helpers;
+namespace PluginManager.Online.Helpers
-
-internal static class OnlineFunctions
 {
-    /// <summary>
+    internal static class OnlineFunctions
-    ///     Downloads a <see cref="Stream" /> and saves it to another <see cref="Stream" />.
-    /// </summary>
-    /// <param name="client">The <see cref="HttpClient" /> that is used to download the file</param>
-    /// <param name="url">The url to the file</param>
-    /// <param name="destination">The <see cref="Stream" /> to save the downloaded data</param>
-    /// <param name="progress">The <see cref="IProgress{T}" /> that is used to track the download progress</param>
-    /// <param name="cancellation">The cancellation token</param>
-    /// <returns></returns>
-    internal static async Task DownloadFileAsync(this HttpClient client, string url, Stream destination,
-                                                 IProgress<float>? progress = null,
-                                                 IProgress<long>? downloadedBytes = null, int bufferSize = 81920,
-                                                 CancellationToken cancellation = default)
     {
-        using (var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellation))
+        /// <summary>
+        /// Downloads a <see cref="Stream"/> and saves it to another <see cref="Stream"/>.
+        /// </summary>
+        /// <param name="client">The <see cref="HttpClient"/> that is used to download the file</param>
+        /// <param name="url">The url to the file</param>
+        /// <param name="destination">The <see cref="Stream"/> to save the downloaded data</param>
+        /// <param name="progress">The <see cref="IProgress{T}"/> that is used to track the download progress</param>
+        /// <param name="cancellation">The cancellation token</param>
+        /// <returns></returns>
+        internal static async Task DownloadFileAsync(this HttpClient client, string url, Stream destination,
+            IProgress<float>? progress = null, IProgress<long>? downloadedBytes = null, CancellationToken cancellation = default)
         {
-            var contentLength = response.Content.Headers.ContentLength;
+            using (var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
-
-            using (var download = await response.Content.ReadAsStreamAsync(cancellation))
             {
-                // Ignore progress reporting when no progress reporter was 
+                var contentLength = response.Content.Headers.ContentLength;
-                // passed or when the content length is unknown
+
-                if (progress == null || !contentLength.HasValue)
+                using (var download = await response.Content.ReadAsStreamAsync())
                 {
-                    await download.CopyToAsync(destination, cancellation);
-                    return;
-                }
 
-                // Convert absolute progress (bytes downloaded) into relative progress (0% - 100%)
+                    // Ignore progress reporting when no progress reporter was 
-                var relativeProgress = new Progress<long>(totalBytes =>
+                    // passed or when the content length is unknown
+                    if (progress == null || !contentLength.HasValue)
                     {
-                        progress?.Report((float)totalBytes / contentLength.Value * 100);
+                        await download.CopyToAsync(destination);
-                        downloadedBytes?.Report(totalBytes);
+                        return;
                     }
-                );
 
-                // Use extension method to report progress while downloading
+                    // Convert absolute progress (bytes downloaded) into relative progress (0% - 100%)
-                await download.CopyToOtherStreamAsync(destination, bufferSize, relativeProgress, cancellation);
+                    var relativeProgress = new Progress<long>(totalBytes =>
-                progress.Report(100);
+                    {
+                        progress.Report((float)totalBytes / contentLength.Value * 100);
+                        downloadedBytes?.Report(totalBytes);
+                    });
+                    // Use extension method to report progress while downloading
+                    await download.CopyToOtherStreamAsync(destination, 81920, relativeProgress, cancellation);
+                    progress.Report(1);
+                }
             }
         }
-    }
 
-    /// <summary>
+        /// <summary>
-    ///     Read contents of a file as string from specified URL
+        /// Read contents of a file as string from specified URL
-    /// </summary>
+        /// </summary>
-    /// <param name="url">The URL to read from</param>
+        /// <param name="url">The URL to read from</param>
-    /// <param name="cancellation">The cancellation token</param>
+        /// <param name="cancellation">The cancellation token</param>
-    /// <returns></returns>
+        /// <returns></returns>
-    internal static async Task<string> DownloadStringAsync(string url, CancellationToken cancellation = default)
+        internal static async Task<string> DownloadStringAsync(string url, CancellationToken cancellation = default)
-    {
+        {
-        using var client = new HttpClient();
+            using (var client = new HttpClient())
-        return await client.GetStringAsync(url, cancellation);
+            {
+                return await client.GetStringAsync(url);
+            }
+        }
+
+
+
     }
-}
+}

PluginManager/Online/Helpers/VersionString.cs

@@ -1,84 +0,0 @@
-using System;
-
-namespace PluginManager.Online.Helpers;
-
-public class VersionString
-{
-    public int PackageCheckVersion;
-    public int PackageMainVersion;
-    public int PackageVersionID;
-
-    public VersionString(string version)
-    {
-        var data = version.Split('.');
-        try
-        {
-            PackageVersionID = int.Parse(data[0]);
-            PackageMainVersion = int.Parse(data[1]);
-            PackageCheckVersion = int.Parse(data[2]);
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine(version);
-            throw new Exception("Failed to write Version", ex);
-        }
-    }
-
-    public override string ToString()
-    {
-        return "{PackageID: " + PackageVersionID + ", PackageVersion: " + PackageMainVersion +
-               ", PackageCheckVersion: " + PackageCheckVersion + "}";
-    }
-
-    public string ToShortString()
-    {
-        if (PackageVersionID == 0 && PackageCheckVersion == 0 && PackageMainVersion == 0)
-            return "Unknown";
-        return $"{PackageVersionID}.{PackageMainVersion}.{PackageCheckVersion}";
-    }
-
-
-    #region operators
-
-    public static bool operator >(VersionString s1, VersionString s2)
-    {
-        if (s1.PackageVersionID > s2.PackageVersionID) return true;
-        if (s1.PackageVersionID == s2.PackageVersionID)
-        {
-            if (s1.PackageMainVersion > s2.PackageMainVersion) return true;
-            if (s1.PackageMainVersion == s2.PackageMainVersion &&
-                s1.PackageCheckVersion > s2.PackageCheckVersion) return true;
-        }
-
-        return false;
-    }
-
-    public static bool operator <(VersionString s1, VersionString s2)
-    {
-        return !(s1 > s2) && s1 != s2;
-    }
-
-    public static bool operator ==(VersionString s1, VersionString s2)
-    {
-        if (s1.PackageVersionID == s2.PackageVersionID && s1.PackageMainVersion == s2.PackageMainVersion &&
-            s1.PackageCheckVersion == s2.PackageCheckVersion) return true;
-        return false;
-    }
-
-    public static bool operator !=(VersionString s1, VersionString s2)
-    {
-        return !(s1 == s2);
-    }
-
-    public static bool operator <=(VersionString s1, VersionString s2)
-    {
-        return s1 < s2 || s1 == s2;
-    }
-
-    public static bool operator >=(VersionString s1, VersionString s2)
-    {
-        return s1 > s2 || s1 == s2;
-    }
-
-    #endregion
-}

PluginManager/Online/PluginsManager.cs

@@ -1,10 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-
-using PluginManager.Online.Helpers;
 using PluginManager.Others;
-
 using OperatingSystem = PluginManager.Others.OperatingSystem;
 
 namespace PluginManager.Online;
@@ -14,41 +11,41 @@ public class PluginsManager
     /// <summary>
     ///     The Plugin Manager constructor
     /// </summary>
-    /// <param name="plink">The link to the file where all plugins are stored</param>
+    /// <param name="link">The link to the file where all plugins are stored</param>
-    /// <param name="vlink">The link to the file where all plugin versions are stored</param>
+    public PluginsManager(string link)
-    public PluginsManager(string plink, string vlink)
     {
-        PluginsLink = plink;
+        PluginsLink = link;
-        VersionsLink = vlink;
     }
 
     /// <summary>
     ///     The URL of the server
     /// </summary>
     public string PluginsLink { get; }
-    public string VersionsLink {get; }
 
     /// <summary>
     ///     The method to load all plugins
     /// </summary>
     /// <returns></returns>
-    public async Task<List<string[]>> GetAvailablePlugins()
+    public async Task ListAvailablePlugins()
     {
         try
         {
-            var list = await ServerCom.ReadTextFromURL(PluginsLink);
+            var list  = await ServerCom.ReadTextFromFile(PluginsLink);
             var lines = list.ToArray();
 
             var data = new List<string[]>();
-            var op = Functions.GetOperatingSystem();
+            var op   = Functions.GetOperatingSystem();
 
-            var len = lines.Length;
+            var      len    = lines.Length;
+            string[] titles = { "Name", "Description", "Plugin Type", "Libraries", "Installed" };
+            data.Add(new[] { "-", "-", "-", "-", "-" });
+            data.Add(titles);
+            data.Add(new[] { "-", "-", "-", "-", "-" });
             for (var i = 0; i < len; i++)
             {
-                if (lines[i].Length <= 2)
+                if (lines[i].Length <= 2) continue;
-                    continue;
                 var content = lines[i].Split(',');
-                var display = new string[4]; // 4 columns
+                var display = new string[titles.Length];
                 if (op == OperatingSystem.WINDOWS)
                 {
                     if (content[4].Contains("Windows"))
@@ -56,9 +53,15 @@ public class PluginsManager
                         display[0] = content[0];
                         display[1] = content[1];
                         display[2] = content[2];
-                        display[3] =
+                        if (content.Length == 6 && (content[5] != null || content[5].Length > 2))
-                            (await GetVersionOfPackageFromWeb(content[0]) ?? new VersionString("0.0.0"))
+                            display[3] = ((await ServerCom.ReadTextFromFile(content[5])).Count + 1).ToString();
-                           .ToShortString();
+
+                        else
+                            display[3] = "1";
+                        if (Config.PluginConfig.Contains(content[0]) || Config.PluginConfig.Contains(content[0]))
+                            display[4] = "✓";
+                        else
+                            display[4] = "X";
                         data.Add(display);
                     }
                 }
@@ -69,43 +72,25 @@ public class PluginsManager
                         display[0] = content[0];
                         display[1] = content[1];
                         display[2] = content[2];
-                        display[3] =
+                        if (content.Length == 6 && (content[5] != null || content[5].Length > 2)) display[3] = ((await ServerCom.ReadTextFromFile(content[5])).Count + 1).ToString();
-                            (await GetVersionOfPackageFromWeb(content[0]) ?? new VersionString("0.0.0"))
+                        if (Config.PluginConfig.Contains(content[0]) || Config.PluginConfig.Contains(content[0]))
-                           .ToShortString();
+                            display[4] = "✓";
+                        else
+                            display[4] = "X";
                         data.Add(display);
                     }
                 }
             }
 
-            data.Add(new[] { "-", "-", "-", "-" });
+            data.Add(new[] { "-", "-", "-", "-", "-" });
 
-            return data;
+            Console_Utilities.FormatAndAlignTable(data);
         }
         catch (Exception exception)
         {
-            Config.Logger.Log("Failed to execute command: listplugs\nReason: " + exception.Message, this, LogLevel.ERROR);
+            Console.WriteLine("Failed to execute command: listlang\nReason: " + exception.Message);
+            Functions.WriteErrFile(exception.ToString());
         }
-
-        return null;
-    }
-
-    public async Task<VersionString?> GetVersionOfPackageFromWeb(string pakName)
-    {
-        var data = await ServerCom.ReadTextFromURL(VersionsLink);
-        foreach (var item in data)
-        {
-            if (item.StartsWith("#"))
-                continue;
-
-            string[] split = item.Split(',');
-            if (split[0] == pakName)
-            {
-                Console.WriteLine("Searched for " + pakName + " and found " + split[1] + " as version.\nUsed url: " + VersionsLink);
-                return new VersionString(split[1]);
-            }
-                
-        }
-        return null;
     }
 
     /// <summary>
@@ -117,27 +102,26 @@ public class PluginsManager
     {
         try
         {
-            var list = await ServerCom.ReadTextFromURL(PluginsLink);
+            var list  = await ServerCom.ReadTextFromFile(PluginsLink);
             var lines = list.ToArray();
-            var len = lines.Length;
+            var len   = lines.Length;
             for (var i = 0; i < len; i++)
             {
                 var contents = lines[i].Split(',');
                 if (contents[0] == name)
                 {
-                    if (contents.Length == 6)
+                    if (contents.Length == 6) return new[] { contents[2], contents[3], contents[5] };
-                        return new[] { contents[2], contents[3], contents[5] };
+                    if (contents.Length == 5) return new[] { contents[2], contents[3], string.Empty };
-                    if (contents.Length == 5)
-                        return new[] { contents[2], contents[3], string.Empty };
                     throw new Exception("Failed to download plugin. Invalid Argument Length");
                 }
             }
         }
         catch (Exception exception)
         {
-            Config.Logger.Log("Failed to execute command: listplugs\nReason: " + exception.Message, this, LogLevel.ERROR);
+            Console.WriteLine("Failed to execute command: listplugs\nReason: " + exception.Message);
+            Functions.WriteErrFile(exception.ToString());
         }
 
         return new string[] { null!, null!, null! };
     }
-}
+}

PluginManager/Online/ServerCom.cs

@@ -1,53 +1,86 @@
-using System;
+using PluginManager.Online.Helpers;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
-using System.Collections.Generic;
-
-using PluginManager.Online.Helpers;
 using PluginManager.Others;
 
-namespace PluginManager.Online;
+namespace PluginManager.Online
-
-public static class ServerCom
 {
-    /// <summary>
+    public class ServerCom
-    ///     Read all lines from a file async
-    /// </summary>
-    /// <param name="link">The link of the file</param>
-    /// <returns></returns>
-    public static async Task<List<string>> ReadTextFromURL(string link)
     {
-        var response = await OnlineFunctions.DownloadStringAsync(link);
-        var lines = response.Split('\n');
-        return lines.ToList();
-    }
 
-    /// <summary>
+        /// <summary>
-    ///     Download file from url
+        /// Read all lines from a file async
-    /// </summary>
+        /// </summary>
-    /// <param name="URL">The url to the file</param>
+        /// <param name="link">The link of the file</param>
-    /// <param name="location">The location where to store the downloaded data</param>
+        /// <returns></returns>
-    /// <param name="progress">The <see cref="IProgress{T}" /> to track the download</param>
+        public static async Task<List<string>> ReadTextFromFile(string link)
-    /// <returns></returns>
-    public static async Task DownloadFileAsync(string URL, string location, IProgress<float> progress,
-                                               IProgress<long>? downloadedBytes)
-    {
-        using (var client = new HttpClient())
         {
-            client.Timeout = TimeSpan.FromMinutes(5);
+            string response = await OnlineFunctions.DownloadStringAsync(link);
+            string[] lines = response.Split('\n');
+            return lines.ToList();
+        }
 
-            using (var file = new FileStream(location, FileMode.Create, FileAccess.Write, FileShare.None))
+        /// <summary>
+        /// Download file from url
+        /// </summary>
+        /// <param name="URL">The url to the file</param>
+        /// <param name="location">The location where to store the downloaded data</param>
+        /// <param name="progress">The <see cref="IProgress{T}"/> to track the download</param>
+        /// <returns></returns>
+        public static async Task DownloadFileAsync(string URL, string location, IProgress<float> progress, IProgress<long>? downloadedBytes = null)
+        {
+            using (var client = new System.Net.Http.HttpClient())
             {
-                await client.DownloadFileAsync(URL, file, progress, downloadedBytes);
+                client.Timeout = TimeSpan.FromMinutes(5);
+
+                using (var file = new FileStream(location, FileMode.Create, FileAccess.Write, FileShare.None))
+                {
+                    await client.DownloadFileAsync(URL, file, progress, downloadedBytes);
+                }
             }
         }
-    }
 
-    public static async Task DownloadFileAsync(string URl, string location, IProgress<float> progress)
+        /// <summary>
-    {
+        /// Download file from url
-        await DownloadFileAsync(URl, location, progress, null);
+        /// </summary>
+        /// <param name="URL">The url to the file</param>
+        /// <param name="location">The location where to store the downloaded data</param>
+        /// <returns></returns>
+        public static async Task DownloadFileAsync(string URL, string location)
+        {
+            bool isDownloading   = true;
+            int  c_progress      = 0;
+
+            Console_Utilities.ProgressBar pbar = new Console_Utilities.ProgressBar { Max = 100, NoColor = true };
+
+            IProgress<float> progress = new Progress<float>(percent =>
+            {
+                c_progress = (int)percent;
+            });
+
+
+            Task updateProgressBarTask = new Task(() =>
+                {
+                    while (isDownloading)
+                    {
+                        pbar.Update(c_progress);
+                        if (c_progress == 100) break;
+                        Thread.Sleep(500);
+                    }
+                }
+            );
+
+            new Thread(updateProgressBarTask.Start).Start();
+            await DownloadFileAsync(URL, location, progress);
+
+
+            c_progress = 100;
+            pbar.Update(100);
+            isDownloading = false;
+        }
     }
-}
+}

PluginManager/Others/Actions/ActionManager.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace PluginManager.Others.Actions
-{
-    public class ActionManager
-    {
-        public List<InternalAction> Actions { get; private set; }
-
-        private bool _isInitialized = false;
-
-        public ActionManager()
-        {
-            if(_isInitialized) return;
-
-            Actions = new List<InternalAction>();
-
-            _isInitialized = true;
-        }
-
-        public bool ActionExists(string name)
-        {
-            if(!_isInitialized) throw new Exception("ActionManager is not initialized");
-            return Actions.Any(x => x.Name == name);
-        }
-
-        public void AddAction(InternalAction action)
-        {
-            if(!_isInitialized) throw new Exception("ActionManager is not initialized");
-            Actions.Add(action);
-        }
-
-        public void ExecuteAction(string name, string[] args)
-        {
-            if(!_isInitialized) throw new Exception("ActionManager is not initialized");
-            var action = Actions.FirstOrDefault(x => x.Name == name);
-            if(action == null) throw new Exception($"Action {name} not found");
-            action.Invoke(args);
-        }
-
-        public async Task ExecuteActionAsync(string name, string[] args)
-        {
-            if(!_isInitialized) throw new Exception("ActionManager is not initialized");
-            var action = Actions.FirstOrDefault(x => x.Name == name);
-            if(action == null) throw new Exception($"Action {name} not found");
-            await action.InvokeAsync(args);
-        }
-    }
-}

PluginManager/Others/Actions/InternalAction.cs

@@ -1,40 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PluginManager.Others.Actions
-{
-    public class InternalAction
-    {
-        public string? Name { get; init; }
-        public Action<string[]> Action { get; init; }
-
-        public InternalAction(string name, Action<string[]> action)
-        {
-            Name = name;
-            Action = action;
-        }
-
-        public InternalAction(string name, Action action)
-        {
-            Name = name;
-            Action = (o) =>
-            {
-                action();
-                return;
-            };
-        }
-
-        public void Invoke(string[] args)
-        {
-            Action(args);
-        }
-
-        public async Task InvokeAsync(string[] args)
-        {
-            await Task.Run(() => Action(args));
-        }
-    }
-}

PluginManager/Others/ArchiveManager.cs

@@ -1,141 +0,0 @@
-using System;
-using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace PluginManager.Others
-{
-    public static class ArchiveManager
-    {
-        public static bool isInitialized { get; private set; }
-        private static string? archiveFolder;
-
-        public static void Initialize()
-        {
-            if (isInitialized) throw new Exception("ArchiveManager is already initialized");
-
-            if (!Config.Data.ContainsKey("ArchiveFolder"))
-                Config.Data["ArchiveFolder"] = "./Data/PAKS/";
-
-            archiveFolder = Config.Data["ArchiveFolder"];
-
-            isInitialized = true;
-
-        }
-        /// <summary>
-        ///     Read data from a file that is inside an archive (ZIP format)
-        /// </summary>
-        /// <param name="FileName">The file name that is inside the archive or its full path</param>
-        /// <param name="archFile">The archive location from the PAKs folder</param>
-        /// <returns>A string that represents the content of the file or null if the file does not exists or it has no content</returns>
-        public static async Task<string?> ReadFromPakAsync(string FileName, string archFile)
-        {
-            if (!isInitialized) throw new Exception("ArchiveManager is not initialized");
-            archFile = archiveFolder + archFile;
-            if (!File.Exists(archFile))
-                throw new Exception("Failed to load file !");
-
-            try
-            {
-                string? textValue = null;
-                using (var fs = new FileStream(archFile, FileMode.Open))
-                using (var zip = new ZipArchive(fs, ZipArchiveMode.Read))
-                {
-                    foreach (var entry in zip.Entries)
-                        if (entry.Name == FileName || entry.FullName == FileName)
-                            using (var s = entry.Open())
-                            using (var reader = new StreamReader(s))
-                            {
-                                textValue = await reader.ReadToEndAsync();
-                                reader.Close();
-                                s.Close();
-                                fs.Close();
-                            }
-                }
-
-                return textValue;
-            }
-            catch (Exception ex)
-            {
-                Config.Logger.Log(ex.Message, "Archive Manager", LogLevel.ERROR); // Write the error to a file
-                await Task.Delay(100);
-                return await ReadFromPakAsync(FileName, archFile);
-            }
-        }
-
-        /// <summary>
-        ///     Extract zip to location
-        /// </summary>
-        /// <param name="zip">The zip location</param>
-        /// <param name="folder">The target location</param>
-        /// <param name="progress">The progress that is updated as a file is processed</param>
-        /// <param name="type">The type of progress</param>
-        /// <returns></returns>
-        public static async Task ExtractArchive(string zip, string folder, IProgress<float> progress,
-                                                UnzipProgressType type)
-        {
-            if (!isInitialized) throw new Exception("ArchiveManager is not initialized");
-            Directory.CreateDirectory(folder);
-            using (var archive = ZipFile.OpenRead(zip))
-            {
-                if (type == UnzipProgressType.PERCENTAGE_FROM_NUMBER_OF_FILES)
-                {
-                    var totalZIPFiles = archive.Entries.Count();
-                    var currentZIPFile = 0;
-                    foreach (var entry in archive.Entries)
-                    {
-                        if (entry.FullName.EndsWith("/")) // it is a folder
-                            Directory.CreateDirectory(Path.Combine(folder, entry.FullName));
-
-                        else
-                            try
-                            {
-                                entry.ExtractToFile(Path.Combine(folder, entry.FullName), true);
-                            }
-                            catch (Exception ex)
-                            {
-                                Config.Logger.Log($"Failed to extract {entry.Name}. Exception: {ex.Message}", "Archive Manager", LogLevel.ERROR);
-                            }
-
-                        currentZIPFile++;
-                        await Task.Delay(10);
-                        if (progress != null)
-                            progress.Report((float)currentZIPFile / totalZIPFiles * 100);
-                    }
-                }
-                else if (type == UnzipProgressType.PERCENTAGE_FROM_TOTAL_SIZE)
-                {
-                    ulong zipSize = 0;
-
-                    foreach (var entry in archive.Entries)
-                        zipSize += (ulong)entry.CompressedLength;
-
-                    ulong currentSize = 0;
-                    foreach (var entry in archive.Entries)
-                    {
-                        if (entry.FullName.EndsWith("/"))
-                        {
-                            Directory.CreateDirectory(Path.Combine(folder, entry.FullName));
-                            continue;
-                        }
-
-                        try
-                        {
-                            entry.ExtractToFile(Path.Combine(folder, entry.FullName), true);
-                            currentSize += (ulong)entry.CompressedLength;
-                        }
-                        catch (Exception ex)
-                        {
-                            Config.Logger.Log($"Failed to extract {entry.Name}. Exception: {ex.Message}", "Archive Manager", LogLevel.ERROR);
-                        }
-
-                        await Task.Delay(10);
-                        if (progress != null)
-                            progress.Report((float)currentSize / zipSize * 100);
-                    }
-                }
-            }
-        }
-    }
-}

PluginManager/Others/Channels.cs

@@ -0,0 +1,60 @@
+using System.Threading.Tasks;
+using Discord;
+
+namespace PluginManager.Others;
+
+/// <summary>
+///     A class that handles the sending of messages to the user.
+/// </summary>
+public static class ChannelManagement
+{
+    /// <summary>
+    ///     Get the text channel by name from server
+    /// </summary>
+    /// <param name="server">The server</param>
+    /// <param name="name">The channel name</param>
+    /// <returns>
+    ///     <see cref="IGuildChannel" />
+    /// </returns>
+    public static IGuildChannel GetTextChannel(this IGuild server, string name)
+    {
+        return server.GetTextChannel(name);
+    }
+
+    /// <summary>
+    ///     Get the voice channel by name from server
+    /// </summary>
+    /// <param name="server">The server</param>
+    /// <param name="name">The channel name</param>
+    /// <returns>
+    ///     <see cref="IGuildChannel" />
+    /// </returns>
+    public static IGuildChannel GetVoiceChannel(this IGuild server, string name)
+    {
+        return server.GetVoiceChannel(name);
+    }
+
+    /// <summary>
+    ///     Get the DM channel between <see cref="Discord.WebSocket.DiscordSocketClient" /> and <see cref="IGuildUser" />
+    /// </summary>
+    /// <param name="user"></param>
+    /// <returns>
+    ///     <see cref="IDMChannel" />
+    /// </returns>
+    public static async Task<IDMChannel> GetDMChannel(IGuildUser user)
+    {
+        return await user.CreateDMChannelAsync();
+    }
+
+    /// <summary>
+    ///     Get the channel where the message was sent
+    /// </summary>
+    /// <param name="message">The message</param>
+    /// <returns>
+    ///     <see cref="IChannel" />
+    /// </returns>
+    public static IChannel GetChannel(IMessage message)
+    {
+        return message.Channel;
+    }
+}

PluginManager/Others/Console Utilities.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+
+namespace PluginManager.Others
+{
+    public class Console_Utilities
+    {
+        /// <summary>
+        /// Progress bar object
+        /// </summary>
+        public class ProgressBar
+        {
+            public int          Max     { get; init; }
+            public ConsoleColor Color   { get; init; }
+            public bool         NoColor { get; init; }
+
+
+            public void Update(int progress, double speed = -1, string? unit = null)
+            {
+                Console.CursorLeft = 0;
+                Console.Write("[");
+                Console.CursorLeft = 32;
+                Console.Write("]");
+                Console.CursorLeft = 1;
+                float onechunk = 30.0f / Max;
+
+                int position = 1;
+
+                for (int i = 0; i < onechunk * progress; i++)
+                {
+                    if (NoColor)
+                        Console.BackgroundColor = ConsoleColor.Black; //this.Color
+                    else
+                        Console.BackgroundColor = this.Color;
+                    Console.CursorLeft      = position++;
+                    Console.Write("#");
+                }
+
+                for (int i = position; i <= 31; i++)
+                {
+                    if (NoColor)
+                        Console.BackgroundColor = ConsoleColor.Black; // background of empty bar
+                    else
+                        Console.BackgroundColor = ConsoleColor.DarkGray;
+                    Console.CursorLeft      = position++;
+                    Console.Write(" ");
+                }
+
+                Console.CursorLeft = 35;
+                Console.BackgroundColor = ConsoleColor.Black;
+                if (speed == -1 || unit == null)
+                {
+                    if (progress == Max)
+                        Console.Write(progress.ToString() + " %      ✓");
+                    else Console.Write(progress.ToString() + " %       ");
+                }
+                else
+                    Console.Write(progress.ToString() + $"{speed} {unit}/s        ");
+
+            }
+        }
+
+
+        /// <summary>
+        /// A way to create a table based on input data
+        /// </summary>
+        /// <param name="data">The List of arrays of strings that represent the rows.</param>
+        public static void FormatAndAlignTable(List<string[]> data)
+        {
+            char tableLine  = '-';
+            char tableCross = '+';
+            char tableWall  = '|';
+
+            int[] len = new int[data[0].Length];
+            foreach (var line in data)
+            {
+                for (int i = 0; i < line.Length; i++)
+                    if (line[i].Length > len[i])
+                        len[i] = line[i].Length;
+            }
+
+
+            foreach (string[] row in data)
+            {
+                if (row[0][0] == tableLine) Console.Write(tableCross);
+                else Console.Write(tableWall);
+                for (int l = 0; l < row.Length; l++)
+                {
+                    if (row[l][0] == tableLine)
+                    {
+                        for (int i = 0; i < len[l] + 4; ++i)
+                            Console.Write(tableLine);
+                    }
+                    else if (row[l].Length == len[l])
+                    {
+                        Console.Write("  ");
+                        Console.Write(row[l]);
+                        Console.Write("  ");
+                    }
+                    else
+                    {
+
+                        int lenHalf = row[l].Length / 2;
+                        for (int i = 0; i < ((len[l] + 4) / 2 - lenHalf); ++i)
+                            Console.Write(" ");
+                        Console.Write(row[l]);
+                        for (int i = (len[l] + 4) / 2 + lenHalf + 1; i < len[l] + 4; ++i)
+                            Console.Write(" ");
+                        if (row[l].Length % 2 == 0)
+                            Console.Write(" ");
+                    }
+
+                    if (row[l][0] == tableLine) Console.Write(tableCross);
+                    else Console.Write(tableWall);
+                }
+                Console.WriteLine(); //end line
+
+            }
+        }
+
+        public static void WriteColorText(string text, bool appendNewLine = true)
+        {
+
+            string[] words = text.Split(' ');
+            ConsoleColor fg = Console.ForegroundColor;
+            Dictionary<string, ConsoleColor> colors = new Dictionary<string, ConsoleColor>()
+            {
+                { "&g", ConsoleColor.Green },
+                { "&b", ConsoleColor.Blue },
+                { "&r", ConsoleColor.Red },
+                { "&m", ConsoleColor.Magenta },
+                { "&y", ConsoleColor.Yellow },
+                { "&c", fg }
+            };
+            foreach (string word in words)
+            {
+                if (word.Length >= 2)
+                {
+                    string prefix = word.Substring(0, 2);
+                    if (colors.ContainsKey(prefix))
+                        Console.ForegroundColor = colors[prefix];
+                }
+
+                string m = word;
+                foreach (var key in colors.Keys) { m = m.Replace(key, ""); }
+
+                Console.Write(m + " ");
+            }
+            if (appendNewLine)
+                Console.Write('\n');
+
+            Console.ForegroundColor = fg;
+        }
+
+    }
+}

PluginManager/Others/DBCommandExecutingArguments.cs

@@ -1,27 +0,0 @@
-using Discord.Commands;
-using Discord.WebSocket;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PluginManager.Others
-{
-    public class DBCommandExecutingArguments
-    {
-        public SocketCommandContext context { get; init; }
-        public string cleanContent { get; init; }
-        public string commandUsed { get;init; }
-        public string[] arguments { get;init; }
-
-        public DBCommandExecutingArguments(SocketCommandContext context, string cleanContent, string commandUsed, string[] arguments)
-        {
-            this.context = context;
-            this.cleanContent = cleanContent;
-            this.commandUsed = commandUsed;
-            this.arguments = arguments;
-        }
-
-    }
-}

PluginManager/Others/Enums.cs

@@ -1,37 +1,29 @@
-namespace PluginManager.Others;
+using PluginManager.Interfaces;
+
+namespace PluginManager.Others;
 
 /// <summary>
 ///     A list of operating systems
 /// </summary>
 public enum OperatingSystem
 {
-    WINDOWS,
+    WINDOWS, LINUX, MAC_OS, UNKNOWN
-    LINUX,
+}
-    MAC_OS,
+
-    UNKNOWN
+/// <summary>
+///     A list with all errors
+/// </summary>
+public enum Error
+{
+    UNKNOWN_ERROR, GUILD_NOT_FOUND, STREAM_NOT_FOUND, INVALID_USER, INVALID_CHANNEL, INVALID_PERMISSIONS
 }
 
 /// <summary>
 ///     The output log type
 /// </summary>
-public enum LogLevel
+public enum OutputLogLevel { NONE, INFO, WARNING, ERROR, CRITICAL }
-{
-    NONE,
-    INFO,
-    WARNING,
-    ERROR,
-    CRITICAL
-}
-
-public enum UnzipProgressType
-{
-    PERCENTAGE_FROM_NUMBER_OF_FILES,
-    PERCENTAGE_FROM_TOTAL_SIZE
-}
-
-public enum SaveType
-{
-    NORMAL,
-    BACKUP
-}
 
+/// <summary>
+/// Plugin Type
+/// </summary>
+public enum PluginType { Command, Event, Unknown }

PluginManager/Others/Functions.cs

@@ -1,103 +1,307 @@
-using System;
+using System.IO.Compression;
 using System.IO;
-using System.Runtime.InteropServices;
+using System;
-using System.Text;
-using System.Text.Json;
-using System.Threading;
 using System.Threading.Tasks;
+using System.Linq;
+using System.Collections.Generic;
+using Discord.WebSocket;
+using PluginManager.Items;
+using System.Threading;
+using System.Text.Json;
+using System.Text;
 
-namespace PluginManager.Others;
+namespace PluginManager.Others
-
-/// <summary>
-///     A special class with functions
-/// </summary>
-public static class Functions
 {
     /// <summary>
-    ///     The location for the Resources folder
+    /// A special class with functions
     /// </summary>
-    public static readonly string dataFolder = @"./Data/Resources/";
+    public static class Functions
-
-    /// <summary>
-    ///     Get the Operating system you are runnin on
-    /// </summary>
-    /// <returns>An Operating system</returns>
-    public static OperatingSystem GetOperatingSystem()
     {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) return OperatingSystem.WINDOWS;
+        /// <summary>
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) return OperatingSystem.LINUX;
+        /// The location for the Resources folder
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) return OperatingSystem.MAC_OS;
+        /// </summary>
-        return OperatingSystem.UNKNOWN;
+        public static readonly string dataFolder = @"./Data/Resources/";
-    }
 
-    /// <summary>
+        /// <summary>
-    ///     Copy one Stream to another <see langword="async" />
+        /// The location for all logs
-    /// </summary>
+        /// </summary>
-    /// <param name="stream">The base stream</param>
+        public static readonly string logFolder = @"./Output/Logs/";
-    /// <param name="destination">The destination stream</param>
-    /// <param name="bufferSize">The buffer to read</param>
-    /// <param name="progress">The progress</param>
-    /// <param name="cancellationToken">The cancellation token</param>
-    /// <exception cref="ArgumentNullException">Triggered if any <see cref="Stream" /> is empty</exception>
-    /// <exception cref="ArgumentOutOfRangeException">Triggered if <paramref name="bufferSize" /> is less then or equal to 0</exception>
-    /// <exception cref="InvalidOperationException">Triggered if <paramref name="stream" /> is not readable</exception>
-    /// <exception cref="ArgumentException">Triggered in <paramref name="destination" /> is not writable</exception>
-    public static async Task CopyToOtherStreamAsync(this Stream stream, Stream destination, int bufferSize,
-                                                    IProgress<long>? progress = null,
-                                                    CancellationToken cancellationToken = default)
-    {
-        if (stream == null) throw new ArgumentNullException(nameof(stream));
-        if (destination == null) throw new ArgumentNullException(nameof(destination));
-        if (bufferSize <= 0) throw new ArgumentOutOfRangeException(nameof(bufferSize));
-        if (!stream.CanRead) throw new InvalidOperationException("The stream is not readable.");
-        if (!destination.CanWrite)
-            throw new ArgumentException("Destination stream is not writable", nameof(destination));
 
-        var buffer = new byte[bufferSize];
+        /// <summary>
-        long totalBytesRead = 0;
+        /// The location for all errors
-        int bytesRead;
+        /// </summary>
-        while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) != 0)
+        public static readonly string errFolder = @"./Output/Errors/";
+
+        /// <summary>
+        /// Archives folder
+        /// </summary>
+        public static readonly string pakFolder = @"./Data/Resources/PAK/";
+
+
+        /// <summary>
+        /// Read data from a file that is inside an archive (ZIP format)
+        /// </summary>
+        /// <param name="FileName">The file name that is inside the archive or its full path</param>
+        /// <param name="archFile">The archive location from the PAKs folder</param> 
+        /// <returns>A string that represents the content of the file or null if the file does not exists or it has no content</returns>
+        public static async Task<Stream?> ReadFromPakAsync(string FileName, string archFile)
         {
-            await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken).ConfigureAwait(false);
+            archFile = pakFolder + archFile;
-            totalBytesRead += bytesRead;
+            Directory.CreateDirectory(pakFolder);
-            progress?.Report(totalBytesRead);
+            if (!File.Exists(archFile)) throw new FileNotFoundException("Failed to load file !");
+
+            Stream? textValue = null;
+            var     fs        = new FileStream(archFile, FileMode.Open);
+            var     zip       = new ZipArchive(fs, ZipArchiveMode.Read);
+            foreach (var entry in zip.Entries)
+            {
+                if (entry.Name == FileName || entry.FullName == FileName)
+                {
+                    Stream       s      = entry.Open();
+                    StreamReader reader = new StreamReader(s);
+                    textValue          = reader.BaseStream;
+                    textValue.Position = 0;
+                    reader.Close();
+                    s.Close();
+                    fs.Close();
+                    break;
+                }
+            }
+
+            return textValue;
+        }
+
+        /// <summary>
+        /// Write logs to file
+        /// </summary>
+        /// <param name="LogMessage">The message to be wrote</param>
+        public static void WriteLogFile(string LogMessage)
+        {
+            string logsPath = logFolder + "Log.txt";
+            if (!Directory.Exists(logFolder)) Directory.CreateDirectory(logFolder);
+            File.AppendAllText(logsPath, LogMessage + " \n");
+        }
+
+        /// <summary>
+        /// Write error to file
+        /// </summary>
+        /// <param name="ErrMessage">The message to be wrote</param>
+        public static void WriteErrFile(string ErrMessage)
+        {
+            string errPath = errFolder + "Error.txt";
+            if (!Directory.Exists(errFolder)) Directory.CreateDirectory(errFolder);
+            File.AppendAllText(errPath, ErrMessage + " \n");
+        }
+
+        /// <summary>
+        /// Merge one array of strings into one string
+        /// </summary>
+        /// <param name="s">The array of strings</param>
+        /// <param name="indexToStart">The index from where the merge should start (included)</param>
+        /// <returns>A string built based on the array</returns>
+        public static string MergeStrings(this string[] s, int indexToStart)
+        {
+            string r   = "";
+            int    len = s.Length;
+            if (len <= indexToStart) return "";
+            for (int i = indexToStart; i < len - 1; ++i)
+            {
+                r += s[i] + " ";
+            }
+
+            r += s[len - 1];
+
+            return r;
+        }
+
+        /// <summary>
+        /// Get the Operating system you are runnin on
+        /// </summary>
+        /// <returns>An Operating system</returns>
+        public static OperatingSystem GetOperatingSystem()
+        {
+            if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows)) return OperatingSystem.WINDOWS;
+            if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Linux)) return OperatingSystem.LINUX;
+            if (System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.OSX)) return OperatingSystem.MAC_OS;
+            return OperatingSystem.UNKNOWN;
+        }
+
+        public static List<string> GetArguments(SocketMessage message)
+        {
+            Command command = new Command(message);
+            return command.Arguments;
+        }
+
+        /// <summary>
+        /// Copy one Stream to another <see langword="async"/>
+        /// </summary>
+        /// <param name="stream">The base stream</param>
+        /// <param name="destination">The destination stream</param>
+        /// <param name="bufferSize">The buffer to read</param>
+        /// <param name="progress">The progress</param>
+        /// <param name="cancellationToken">The cancellation token</param>
+        /// <exception cref="ArgumentNullException">Triggered if any <see cref="Stream"/> is empty</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Triggered if <paramref name="bufferSize"/> is less then or equal to 0</exception>
+        /// <exception cref="InvalidOperationException">Triggered if <paramref name="stream"/> is not readable</exception>
+        /// <exception cref="ArgumentException">Triggered in <paramref name="destination"/> is not writable</exception>
+        public static async Task CopyToOtherStreamAsync(this Stream stream, Stream destination, int bufferSize, IProgress<long>? progress = null, CancellationToken cancellationToken = default)
+        {
+            if (stream == null) throw new ArgumentNullException(nameof(stream));
+            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            if (bufferSize <= 0) throw new ArgumentOutOfRangeException(nameof(bufferSize));
+            if (!stream.CanRead) throw new InvalidOperationException("The stream is not readable.");
+            if (!destination.CanWrite) throw new ArgumentException("Destination stream is not writable", nameof(destination));
+
+            byte[] buffer         = new byte[bufferSize];
+            long   totalBytesRead = 0;
+            int    bytesRead;
+            while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) != 0)
+            {
+                await destination.WriteAsync(buffer, 0, bytesRead, cancellationToken).ConfigureAwait(false);
+                totalBytesRead += bytesRead;
+                progress?.Report(totalBytesRead);
+            }
+
+        }
+
+        /// <summary>
+        /// Extract zip to location
+        /// </summary>
+        /// <param name="zip">The zip location</param>
+        /// <param name="folder">The target location</param>
+        /// <returns></returns>
+        public static async Task ExtractArchive(string zip, string folder, IProgress<float> progress)
+        {
+            if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);
+
+
+            using (ZipArchive archive = ZipFile.OpenRead(zip))
+            {
+                int totalZIPFiles  = archive.Entries.Count();
+                int currentZIPFile = 0;
+                foreach (ZipArchiveEntry entry in archive.Entries)
+                {
+                    if (entry.FullName.EndsWith("/"))
+                        Directory.CreateDirectory(Path.Combine(folder, entry.FullName));
+
+                    else
+                        try
+                        {
+                            entry.ExtractToFile(Path.Combine(folder, entry.FullName), true);
+                        }
+                        catch
+                        {
+                        }
+
+                    currentZIPFile++;
+                    await Task.Delay(10);
+                    progress.Report((float)currentZIPFile / totalZIPFiles * 100);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Convert Bytes to highest measurement unit possible
+        /// </summary>
+        /// <param name="bytes">The amount of bytes</param>
+        /// <returns></returns>
+        public static (double, string) ConvertBytes(long bytes)
+        {
+            List<string> units = new List<string>()
+            {
+                "B",
+                "KB",
+                "MB",
+                "GB",
+                "TB"
+            };
+            int i = 0;
+            while (bytes >= 1024)
+            {
+                i++;
+                bytes /= 1024;
+            }
+
+            return (bytes, units[i]);
+        }
+
+        /// <summary>
+        /// Save to JSON file
+        /// </summary>
+        /// <typeparam name="T">The class type</typeparam>
+        /// <param name="file">The file path</param>
+        /// <param name="Data">The values</param>
+        /// <returns></returns>
+        public static async Task SaveToJsonFile<T>(string file, T Data)
+        {
+            var s = File.OpenWrite(file);
+            await JsonSerializer.SerializeAsync(s, Data, typeof(T), new JsonSerializerOptions { WriteIndented = true });
+            s.Close();
+        }
+
+        /// <summary>
+        /// Convert json text or file to some kind of data
+        /// </summary>
+        /// <typeparam name="T">The data type</typeparam>
+        /// <param name="input">The file or json text</param>
+        /// <returns></returns>
+        public static async Task<T> ConvertFromJson<T>(string input)
+        {
+            Stream text;
+            if (File.Exists(input))
+                text = File.Open(input, FileMode.OpenOrCreate);
+
+            else
+                text = new MemoryStream(Encoding.ASCII.GetBytes(input));
+            text.Position = 0;
+            var obj = await JsonSerializer.DeserializeAsync<T>(text);
+            text.Close();
+            return (obj ?? default)!;
+        }
+
+        /// <summary>
+        /// Check if all words from <paramref name="str"/> are in <paramref name="baseString"/><br/>
+        /// This function returns true if<br/>
+        /// 1. The <paramref name="str"/> is part of <paramref name="baseString"/><br/>
+        /// 2. The words (split by a space) of <paramref name="str"/> are located (separately) in <paramref name="baseString"/> <br/>
+        /// <example>
+        /// The following example will return <see langword="TRUE"/><br/>
+        /// <c>STRContains("Hello World !", "I type word Hello and then i typed word World !")</c><br/>
+        /// The following example will return <see langword="TRUE"/><br/>
+        /// <c>STRContains("Hello World !", "I typed Hello World !" </c><br/>
+        /// The following example will return <see langword="TRUE"/><br/>
+        ///  <c>STRContains("Hello World", "I type World then Hello")</c><br/>
+        /// The following example will return <see langword="FALSE"/><br/>
+        /// <c>STRContains("Hello World !", "I typed Hello World")</c><br/>
+        /// </example>
+        /// </summary>
+        /// <param name="str">The string you are checking</param>
+        /// <param name="baseString">The main string that should contain <paramref name="str"/></param>
+        /// <returns></returns>
+        public static bool STRContains(this string str, string baseString)
+        {
+            if (baseString.Contains(str)) return true;
+            string[] array = str.Split(' ');
+            foreach (var s in array)
+                if (!baseString.Contains(s))
+                    return false;
+            return true;
+        }
+
+        public static bool TryReadValueFromJson(string input, string codeName, out JsonElement element)
+        {
+            Stream text;
+            if (File.Exists(input))
+                text = File.OpenRead(input);
+
+            else
+                text = new MemoryStream(Encoding.ASCII.GetBytes(input));
+
+            var jsonObject = JsonDocument.Parse(text);
+
+            var data = jsonObject.RootElement.TryGetProperty(codeName, out element);
+            return data;
         }
     }
-
+}
-    /// <summary>
-    ///     Save to JSON file
-    /// </summary>
-    /// <typeparam name="T">The class type</typeparam>
-    /// <param name="file">The file path</param>
-    /// <param name="Data">The values</param>
-    /// <returns></returns>
-    public static async Task SaveToJsonFile<T>(string file, T Data)
-    {
-        var str = new MemoryStream();
-        await JsonSerializer.SerializeAsync(str, Data, typeof(T), new JsonSerializerOptions { WriteIndented = true });
-        await File.WriteAllBytesAsync(file, str.ToArray());
-        await str.FlushAsync();
-        str.Close();
-    }
-
-    /// <summary>
-    ///     Convert json text or file to some kind of data
-    /// </summary>
-    /// <typeparam name="T">The data type</typeparam>
-    /// <param name="input">The file or json text</param>
-    /// <returns></returns>
-    public static async Task<T> ConvertFromJson<T>(string input)
-    {
-        Console.WriteLine(input);
-        Stream text;
-        if (File.Exists(input))
-            text = new MemoryStream(await File.ReadAllBytesAsync(input));
-        else
-            text = new MemoryStream(Encoding.ASCII.GetBytes(input));
-        text.Position = 0;
-        var obj = await JsonSerializer.DeserializeAsync<T>(text);
-        await text.FlushAsync();
-        text.Close();
-        return (obj ?? default)!;
-    }
-}

PluginManager/Others/Logger/DBLogger.cs

@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PluginManager.Others.Logger
-{
-    public class DBLogger
-    {
-        
-        private List<LogMessage> LogHistory = new List<LogMessage>();
-        private List<LogMessage> ErrorHistory = new List<LogMessage>();
-
-        public IReadOnlyList<LogMessage> Logs => LogHistory;
-        public IReadOnlyList<LogMessage> Errors => ErrorHistory;
-
-        public delegate void LogHandler(string message, LogLevel logType);
-        public event LogHandler LogEvent;
-
-        private string _logFolder;
-        private string _errFolder;
-
-        public DBLogger()
-        {
-            _logFolder = Config.Data["LogFolder"];
-            _errFolder = Config.Data["ErrorFolder"];
-        }
-
-        public void Log(string message, string sender = "unknown", LogLevel type = LogLevel.INFO) => Log(new LogMessage(message, type, sender));
-
-        public void Log(LogMessage message)
-        {
-            if(LogEvent is not null)
-                LogEvent?.Invoke(message.Message, message.Type);
-
-            if (message.Type != LogLevel.NONE)
-                LogHistory.Add(message);
-            else
-                ErrorHistory.Add(message);
-        }
-
-        public void Log(string message, object sender, LogLevel type = LogLevel.NONE) => Log(message, sender.GetType().Name, type);
-
-        public async void SaveToFile()
-        {
-            await Functions.SaveToJsonFile(_logFolder + "/" + DateTime.Now.ToString("yyyy-MM-dd") + ".json", LogHistory);
-            await Functions.SaveToJsonFile(_errFolder + "/" + DateTime.Now.ToString("yyyy-MM-dd") + ".json", ErrorHistory);
-        }
-    }
-}

PluginManager/Others/Logger/LogMessage.cs

@@ -1,47 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PluginManager.Others.Logger
-{
-    public class LogMessage
-    {
-        public string Message { get; set; }
-        public LogLevel Type { get; set; }
-        public string Time { get; set; }
-        public string Sender { get; set; }
-        public LogMessage(string message, LogLevel type)
-        {
-            Message = message;
-            Type = type;
-            Time = DateTime.Now.ToString("HH:mm:ss");
-        }
-
-        public LogMessage(string message, LogLevel type, string sender) : this(message, type)
-        {
-            Sender = sender;
-        }
-
-        public override string ToString()
-        {
-            return $"[{Time}] {Message}";
-        }
-
-        public static explicit operator LogMessage(string message)
-        {
-            return new LogMessage(message, LogLevel.INFO);
-        }
-
-        public static explicit operator LogMessage((string message, LogLevel type) tuple)
-        {
-            return new LogMessage(tuple.message, tuple.type);
-        }
-
-        public static explicit operator LogMessage((string message, LogLevel type, string sender) tuple)
-        {
-            return new LogMessage(tuple.message, tuple.type, tuple.sender);
-        }
-    }
-}

PluginManager/Others/Permissions/DiscordPermissions.cs

@@ -1,5 +1,4 @@
 using System.Linq;
-
 using Discord;
 using Discord.WebSocket;
 
@@ -62,4 +61,4 @@ public static class DiscordPermissions
     {
         return isAdmin((SocketGuildUser)user);
     }
-}
+}

PluginManager/PluginManager.csproj

@@ -1,18 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
+
-    <TargetFramework>net6.0</TargetFramework>
+	<PropertyGroup>
-    <Nullable>enable</Nullable>
+		<TargetFramework>net6.0</TargetFramework>
-  </PropertyGroup>
+		<Nullable>enable</Nullable>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+	</PropertyGroup>
-    <FileAlignment>512</FileAlignment>
+
-    <DebugType>none</DebugType>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <DebugSymbols>false</DebugSymbols>
+	  <FileAlignment>512</FileAlignment>
-  </PropertyGroup>
+	  <DebugType>none</DebugType>
-  <ItemGroup>
+	  <DebugSymbols>false</DebugSymbols>
-    <None Remove="BlankWindow1.xaml" />
+	</PropertyGroup>
-  </ItemGroup>
+
-  <ItemGroup>
+	<ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.8.1" />
+	  <None Remove="BlankWindow1.xaml" />
-    <PackageReference Include="System.Data.SQLite.Core" Version="1.0.117" />
+	</ItemGroup>
-  </ItemGroup>
+
-</Project>
+	<ItemGroup>
+		<PackageReference Include="Discord.Net" Version="3.7.2" />
+	</ItemGroup>
+
+</Project>

README.md

@@ -5,6 +5,7 @@ This project is based on:
 
 - [.NET 6 (C#)](https://dotnet.microsoft.com/en-us/download/dotnet/6.0)
 - [Discord.Net](https://github.com/discord-net/Discord.Net)
+- [Avalonia UI](https://avaloniaui.net/) for `DiscordBotUI` extension
 
 
 ## Plugins
@@ -15,87 +16,88 @@ This project is based on:
 Plugin Types:
 1. Commands
 2. Events
-3. Slash Commands
+
+Project Structure
+
+![Image](../../blob/gh-pages/Pictures/architecture2.png)
 
 ### How to create a plugin
 
-First of all, create a new project (class library) in Visual Studio.
+First of all, Create a new project (class library) in Visual Studio.
-Then import the PluginManager as reference to your project.
+![Imgur Image](https://i.imgur.com/KUqzKsB.png)
 
-## 1. Commands
+![Imgur Image](https://i.imgur.com/JzpEViR.png)
 
-Commands are loaded when all plugins are loaded into memory. The Execute method is called whenever any user (that respects the `requireAdmin` propery) calls the command using the bot prefix and the `Command`.
+![Imgur Image](https://i.imgur.com/vtoEepX.png)
+
+![Imgur Image](https://i.imgur.com/ceaVR2R.png)
+
+Now, let's add the PluginManager reference. It can be found inside the bot's main folder under
+`DiscordBot/bin/Debug/net6.0/PluginManager.dll` or `PluginManager/bin/Debug/net6.0/PluginManager.dll`
+after one successfull build.
+
+![Imgur Image](https://i.imgur.com/UMSitk4.png)
+
+![Imgur Image](https://i.imgur.com/GEjShdl.png)
+
+1. Commands
+
+Commands are loaded when all plugins are loaded into memory. When an user executes the command, only then the Execute function is called.
 Commands are plugins that allow users to interact with them. 
-Here is an example:
+Here is an example of class that is a command class
 ```cs
-using Discord;
 using Discord.Commands;
+using Discord.WebSocket;
 
 using PluginManager.Interfaces;
 
-namespace LevelingSystem;
+namespace CMD_Utils
-
-internal class LevelCommand : DBCommand
 {
-    public string Command => "level";
+    class FlipCoin : DBCommand
-
-    public List<string> Aliases => new() { "lvl" };
-
-    public string Description => "Display your current level";
-
-    public string Usage => "level";
-
-    public bool requireAdmin => false;
-
-    public async void ExecuteServer(CmdArgs context)
     {
-        //Variables.database is a sql connection that is defined in an auxiliary file in the same napespace as this class
+        public string Command => "flip";
-        object[] user = await Variables.database.ReadDataArrayAsync($"SELECT * FROM Levels WHERE UserID='{context.Message.Author.Id}'");
+
-        if (user is null)
+        public string Description => "Flip a coin";
+
+        public string Usage => "flip";
+
+        public bool canUseDM => true;
+
+        public bool canUseServer => true;
+
+        public bool requireAdmin => false;
+
+        public async void Execute(SocketCommandContext context, SocketMessage message, DiscordSocketClient client, bool isDM)
         {
-            await context.Channel.SendMessageAsync("You are now unranked !");
+            System.Random random = new System.Random();
-            return;
+            int r = random.Next(1, 3);
+            if (r == 1)
+                await message.Channel.SendMessageAsync("Heads");
+            else await message.Channel.SendMessageAsync("Tails");
         }
-
-        int level = (int)user[1];
-        int exp = (int)user[2];
-
-        var builder = new EmbedBuilder();
-        var r = new Random();
-        builder.WithColor(r.Next(256), r.Next(256), r.Next(256));
-        builder.AddField("Current Level", level, true)
-               .AddField("Current EXP", exp, true)
-               .AddField("Required Exp", (level * 8 + 24).ToString(), true);
-        builder.WithTimestamp(DateTimeOffset.Now);
-        builder.WithAuthor(context.Message.Author.Mention);
-        await context.Channel.SendMessageAsync(embed: builder.Build());
     }
-
-    //Optional method (tell the bot what should it do if the command is executed from a DM channel)
-    //public async void ExecuteDM(CmdArgs context) {
-    //
-    //}
 }
 
-
 ```
 #### Code description:
 - Command - The keyword that triggers the execution for the command. This is what players must type in order to execute your command
-- Aliases - The aliases that can be used instead of the full name to execute the command
 - Description - The description of your command. Can be anything you like
 - Usage - The usage of your command. This is what `help [Command]` command will display
+- canUseDM - true if you plan to let users execute this command in DM chat with bot
+- canUseServer - true if you plan to let the users execute this command in a server chat
 - requireAdmin - true if this command requres an user with Administrator permission in the server
-- ExecuteServer () - the function that is executed only when the command is invoked in a server channel.  (optional)
+- Execute () - the function of your command.
-  - context - the command context
-- ExecuteDM () - the function that is executed only when the command is invoked in a private (DM) channel.  (optional)
   - context - the command context
+  - message - the message itself
+  - client - the discord bot client
+  - isDM - true if the message was sent from DM chat
 
 From here on, start coding. When your plugin is done, build it as any DLL project then add it to the following path
-`{bot_executable}/Data/Plugins/<optional subfolder>/[plugin name].dll`
+`{bot_executable}/Data/Plugins/Commands/<optional subfolder>/yourDLLName.dll`
 Then, reload bot and execute command `lp` in bot's console. The plugin should be loaded into memory or an error is thrown if not. If an error is thrown, then
 there is something wrong in your command's code.
 
-## 2. Events
+2. Events
 
 Events are loaded when all plugins are loaded. At the moment when they are loaded, the Start function is called.
 Events are used if you want the bot to do something when something happens in server. The following example shows you how to catch when a user joins the server
@@ -113,6 +115,8 @@ public class OnUserJoin : DBEvent
 
     public async void Start(Discord.WebSocket.DiscordSocketClient client)
     {
+        Console.WriteLine($"Hello World from {name}");
+        
         client.UserJoined += async (user) => {
             await (await user.CreateDMChannelAsync()).SendMessageAsync("Welcome to server !");
         };
@@ -126,68 +130,3 @@ public class OnUserJoin : DBEvent
 - Start() - The main body of your event. This is executed when the bot loads all plugins
   - client - the discord bot client
 
-
-## 3. Slash Commands
-
-
-Slash commands are server based commands. They work the same way as normal commands, but they require the `/` prefix as they are integrated
-with the UI of Discord.
-Here is an example:
-```cs
-using Discord;
-using Discord.WebSocket;
-
-using PluginManager.Interfaces;
-
-namespace SlashCommands
-{
-    public class Random : DBSlashCommand
-    {
-        public string Name => "random";
-
-        public string Description => "Generates a random nunber between 2 values";
-
-        public bool canUseDM => true;
-
-        public List<SlashCommandOptionBuilder> Options => new List<SlashCommandOptionBuilder>()
-        {
-            new SlashCommandOptionBuilder() {Name = "min-value", Description = "Minimum value", IsRequired=true, Type = ApplicationCommandOptionType.Integer, MinValue = 0, MaxValue = int.MaxValue-1},
-            new SlashCommandOptionBuilder() {Name = "max-value", Description = "Maximum value", IsRequired=true, Type=ApplicationCommandOptionType.Integer,MinValue = 0, MaxValue = int.MaxValue-1}
-        };
-
-        public async void ExecuteServer(SocketSlashCommand command)
-        {
-            var rnd = new System.Random();
-            var options = command.Data.Options.ToArray();
-            if (options.Count() != 2)
-            {
-                await command.RespondAsync("Invalid parameters", ephemeral: true);
-                return;
-            }
-
-            Int64 numberOne = (Int64)options[0].Value;
-            Int64 numberTwo = (Int64)options[1].Value;
-
-            await command.RespondAsync("Your generated number is " + rnd.Next((int)numberOne, (int)numberTwo), ephemeral: true);
-
-        }
-    }
-}
-```
-
-#### Code description:
-- Name - the command name (execute with /{Name})
-- Description - The description of the command
-- canUseDM - true id this command can be activated in DM chat, false otherwise
-- Options - the arguments of the command
-- ExecuteServer() - this function will be called if the command is invoked in a server channel  (optional)
-  - context - the command context
-- ExecuteDM() - this function will be called if the command is invoked in a DM channel  (optional)
-  - context - the command context
-
-
-## Note: 
-You can create multiple commands, events and slash commands into one single plugin (class library). The PluginManager will detect the classes and load them individualy. If there are more commands (normal commands, events or slash commands) into a single project (class library) they can use the same resources (a class for example) that is contained within the plugin. 
-
-
-> Updated: 7.04.2023

SethDiscordBot.sln

@@ -1,33 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.1.32421.90
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DiscordBot", "DiscordBot\DiscordBot.csproj", "{087E64F4-1E1C-4899-8223-295356C9894A}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PluginManager", "PluginManager\PluginManager.csproj", "{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{087E64F4-1E1C-4899-8223-295356C9894A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{087E64F4-1E1C-4899-8223-295356C9894A}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{087E64F4-1E1C-4899-8223-295356C9894A}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{087E64F4-1E1C-4899-8223-295356C9894A}.Release|Any CPU.Build.0 = Release|Any CPU
-		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{EDD4D9B3-98DD-4367-A09F-D1C5ACB61132}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {3FB3C5DE-ED21-4D2E-ABDD-3A00EE4A2FFF}
-	EndGlobalSection
-EndGlobal

TODO

@@ -0,0 +1,70 @@
+Discord Bot:
+    ✔ Create bootloader 
+    ✔ Create commands handler 
+    ✔ Create bot launcher
+    ✔ Enable startup commands
+    ✔ Enable console input
+    ☐ Create self update feature 
+
+
+
+Plugin Manager:
+    Define plugin interface:
+        ✔ DBCommand 
+        ✔ DBPlugin 
+    
+    Functions.cs:
+        ✔ Read from file 
+        ✔ Read from archive (PAK) 
+        ✔ Write Logs & Errors 
+        ✔ Manipulate settings (files) and strings 
+        ✔ Stream copy async 
+    
+    Console Utilities:
+        ✔ Progress bar 
+        ✔ Create table 
+        ✔ Write to console with colors 
+    
+    Discord Permissions:
+        ✔ Check if user has permission 
+        ✔ Check if user is owner
+    
+    Discord Plugins:
+        ✔ Create loader for commands
+        ✔ Create loader for events 
+        ☐ Improve memory efficiency 
+        ☐ Improve performance 
+        ☐ Improve stability 
+    
+    Language System:
+        ✔ Create language system 
+        ✔ Load language files 
+
+    Server Communication:
+        ✔ Plugin Download system 
+        ✔ Language Download system
+        ☐ Move to a new server 
+            ☐ Create plugin versioning system
+            ☐ Create plugin update system
+        
+
+
+Plugins:
+    Events:
+        ✔ Leveling system
+        Utilities:
+            ✔ Random number generator 
+            ✔ Flip a coin
+            ✔ Poll
+    
+    Commands:
+        ✔ Leveling system 
+        ☐ Music Commands @started
+    
+    // Windows only version
+    // Download as a patch but replaces old DiscordBot executable with a new one
+    // Adds new dll to support windows forms
+    // Must act the same as the old version
+    ☐ Create version of discord bot with windows form 
+        ☐ Download system and patch will result in a windows only based version of bot
+        ☐ Possibility to reverse patch to get back to original version

Version.txt

@@ -0,0 +1 @@
+0

builder.sh

@@ -1,36 +0,0 @@
-# All files in this directory will be copied to the root of the container
-
-echo "Building..."
-
-echo "Building linux-x64 not self-contained"
-dotnet publish -r linux-x64 -p:PublishSingleFile=false --self-contained false -c Release -o ./publish/linux-x64
-
-echo "Building win-x64 not self-contained"
-dotnet publish -r win-x64 -p:PublishSingleFile=false --self-contained false -c Release -o ./publish/win-x64
-
-echo "Building osx-x64 not self-contained"
-dotnet publish -r osx-x64 -p:PublishSingleFile=false --self-contained false -c Release -o ./publish/osx-x64
-
-#One file per platform
-echo "Building linux-x64 self-contained"
-dotnet publish -r linux-x64 -p:PublishSingleFile=true --self-contained true -c Release -o ./publish/linux-x64-selfcontained
-
-echo "Building win-x64 self-contained"
-dotnet publish -r win-x64 -p:PublishSingleFile=true --self-contained true -c Release -o ./publish/win-x64-selfcontained
-
-echo "Building osx-x64 self-contained"
-dotnet publish -r osx-x64 -p:PublishSingleFile=true --self-contained true -c Release -o ./publish/osx-x64-selfcontained
-
-echo "Zipping..."
-mkdir ./publish/zip
-
-
-zip -r ./publish/zip/linux-x64.zip ./publish/linux-x64
-zip -r ./publish/zip/win-x64.zip ./publish/win-x64
-zip -r ./publish/zip/osx-x64.zip ./publish/osx-x64
-
-zip -r ./publish/zip/linux-x64-selfcontained.zip ./publish/linux-x64-selfcontained
-zip -r ./publish/zip/win-x64-selfcontained.zip ./publish/win-x64-selfcontained
-zip -r ./publish/zip/osx-x64-selfcontained.zip ./publish/osx-x64-selfcontained
-
-echo "Done!"