Merge branch 'preview'

.gitignore

@@ -362,11 +362,3 @@ MigrationBackup/
 
 # Fody - auto-generated XML schema
 FodyWeavers.xsd
-
-*.txt
-
-#folders
-/Plugins/
-/DiscordBot.rar
-/DiscordBot/Data/
-/DiscordBot/Updater/

.vscode/settings.json

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

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,9 +1,6 @@
-using System.Collections.Generic;
-
-using Discord;
+using Discord;
 using Discord.Commands;
-
-using PluginManager;
+using Discord.WebSocket;
 using PluginManager.Interfaces;
 using PluginManager.Loaders;
 using PluginManager.Others;
@@ -20,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
@@ -41,18 +46,21 @@ internal class Help : DBCommand
     ///     The main body of the command
     /// </summary>
     /// <param name="context">The command context</param>
-    public void ExecuteServer(SocketCommandContext context)
+    /// <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)
     {
-        var args = Functions.GetArguments(context.Message);
+        var args = Functions.GetArguments(message);
         if (args.Count != 0)
         {
             foreach (var item in args)
             {
                 var e = GenerateHelpCommand(item);
-                if (e is null)
-                    context.Channel.SendMessageAsync("Unknown Command " + item);
-                else
+                if (e != null)
                     context.Channel.SendMessageAsync(embed: e.Build());
+                else
+                    context.Channel.SendMessageAsync("Unknown Command " + item);
             }
 
             return;
@@ -62,30 +70,30 @@ internal class Help : DBCommand
 
         var adminCommands  = "";
         var normalCommands = "";
+        var DMCommands     = "";
 
         foreach (var cmd in PluginLoader.Commands!)
+        {
+            if (cmd.canUseDM) DMCommands += cmd.Command + " ";
             if (cmd.requireAdmin)
                 adminCommands                         += cmd.Command + " ";
-            else
-                normalCommands += cmd.Command + " ";
+            else if (cmd.canUseServer) normalCommands += cmd.Command + " ";
+        }
 
         embedBuilder.AddField("Admin Commands", adminCommands);
         embedBuilder.AddField("Normal Commands", normalCommands);
+        embedBuilder.AddField("DM Commands", DMCommands);
         context.Channel.SendMessageAsync(embed: embedBuilder.Build());
     }
 
     private EmbedBuilder GenerateHelpCommand(string command)
     {
         var embedBuilder = new EmbedBuilder();
-        var cmd = PluginLoader.Commands!.Find(p => p.Command == command ||
-                                                   (p.Aliases is not null && p.Aliases.Contains(command)));
+        var cmd          = PluginLoader.Commands.Find(p => p.Command == command);
         if (cmd == null) return null;
 
-        embedBuilder.AddField("Usage", Config.Variables.GetValue("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

@@ -1,8 +1,9 @@
 using System;
-using System.Collections.Generic;
 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;
@@ -16,8 +17,6 @@ internal class Restart : DBCommand
     /// </summary>
     public string Command => "restart";
 
-    public List<string> Aliases => null;
-
     /// <summary>
     ///     Command Description
     /// </summary>
@@ -28,18 +27,32 @@ internal class Restart : DBCommand
     /// </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 => true;
+    public bool requireAdmin => false;
 
     /// <summary>
     ///     The main body of the command
     /// </summary>
     /// <param name="context">The command context</param>
-    public async void ExecuteServer(DiscordLibCommands.SocketCommandContext context)
+    /// <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)
     {
-        var args = Functions.GetArguments(context.Message);
+        if (!(message.Author as SocketGuildUser).hasPermission(DiscordLib.GuildPermission.Administrator)) return;
+        var args = Functions.GetArguments(message);
         var OS   = Functions.GetOperatingSystem();
         if (args.Count == 0)
         {

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,10 +1,10 @@
 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 DiscordBot.Discord.Core;
@@ -60,29 +60,17 @@ internal class Boot
     /// <returns>Task</returns>
     public async Task Awake()
     {
-        var config = new DiscordSocketConfig
-        {
-
-            AlwaysDownloadUsers = true,
-
-            //Disable system clock checkup (for responses at slash commands)
-            UseInteractionSnowflakeDate = false
-        };
-
-        client = new DiscordSocketClient(config);
+        client  = new DiscordSocketClient();
         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) ;
     }
@@ -96,22 +84,29 @@ internal class Boot
         client.Ready     += Ready;
     }
 
-    private async Task Client_LoggedOut()
+    private Task Client_LoggedOut()
     {
         WriteLogFile("Successfully Logged Out");
-        await Log(new LogMessage(LogSeverity.Info, "Boot", "Successfully logged out from discord !"));
-
-        /*        var cmds = await client.GetGlobalApplicationCommandsAsync();
-                foreach (var cmd in cmds)
-                    await cmd.DeleteAsync();*/
+        Log(new LogMessage(LogSeverity.Info, "Boot", "Successfully logged out from discord !"));
+        return Task.CompletedTask;
     }
 
-    private async Task Ready()
+    private Task Ready()
     {
         Console.Title = "ONLINE";
-
-
         isReady       = true;
+
+        new Thread(() =>
+            {
+                while (true)
+                {
+                    Config.SaveConfig();
+                    Thread.Sleep(10000);
+                }
+            }
+        ).Start();
+
+        return Task.CompletedTask;
     }
 
     private Task LoggedIn()

DiscordBot/Discord/Core/CommandHandler.cs

@@ -1,11 +1,8 @@
-using System;
-using System.Linq;
+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;
@@ -38,34 +35,9 @@ internal class CommandHandler
     public async Task InstallCommandsAsync()
     {
         client.MessageReceived += MessageHandler;
-        client.SlashCommandExecuted += Client_SlashCommandExecuted;
         await commandService.AddModulesAsync(Assembly.GetEntryAssembly(), null);
     }
 
-    private async 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)
-        {
-
-            Console.WriteLine(ex.ToString());
-            ex.WriteErrFile();
-        }
-
-    }
-
     /// <summary>
     ///     The message handler for the bot
     /// </summary>
@@ -75,16 +47,13 @@ internal class CommandHandler
     {
         try
         {
-            if (Message as SocketUserMessage == null)
-                return;
+            if (Message as SocketUserMessage == null) return;
 
             var message = Message as SocketUserMessage;
 
-            if (message == null)
-                return;
+            if (message == null) return;
 
-            if (!message.Content.StartsWith(botPrefix))
-                return;
+            if (!message.Content.StartsWith(botPrefix)) return;
 
             var argPos = 0;
 
@@ -94,33 +63,69 @@ internal class CommandHandler
                 return;
             }
 
-            if (message.Author.IsBot)
-                return;
+            if (message.Author.IsBot) return;
 
             var context = new SocketCommandContext(client, message);
 
-            await commandService.ExecuteAsync(context, argPos, null);
+            await commandService.ExecuteAsync(
+                context,
+                argPos,
+                null
+            );
 
-            var plugin = PluginLoader.Commands!
-                                     .Where(
-                                          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))))
-                                     .FirstOrDefault();
+            var plugin = PluginLoader.Commands!.Where(p => p.Command == message.Content.Split(' ')[0].Substring(botPrefix.Length)).FirstOrDefault();
 
-            if (plugin is null) throw new Exception("Failed to run command. !");
 
-            if (plugin.requireAdmin && !context.Message.Author.isAdmin())
-                return;
-
-            if (context.Channel is SocketDMChannel)
-                plugin.ExecuteDM(context);
-            else plugin.ExecuteServer(context);
-        }
-        catch (Exception ex)
+            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
         {
-            ex.WriteErrFile();
         }
     }
 }

DiscordBot/DiscordBot - Backup.csproj

@@ -1,52 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-	<PropertyGroup>
-		<OutputType>Exe</OutputType>
-		<TargetFramework>net6.0</TargetFramework>
-		<Nullable>disable</Nullable>
-		<ApplicationIcon />
-		<StartupObject />
-		<SignAssembly>False</SignAssembly>
-		<IsPublishable>True</IsPublishable>
-		<AssemblyVersion>1.0.1.0</AssemblyVersion>
-	</PropertyGroup>
-
-	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-		<DebugType>none</DebugType>
-	</PropertyGroup>
-
-	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-		<DebugType>none</DebugType>
-	</PropertyGroup>
-
-	<ItemGroup>
-		<Compile Remove="Data\**" />
-		<Compile Remove="obj\**" />
-		<Compile Remove="Output\**" />
-	</ItemGroup>
-
-	<ItemGroup>
-		<EmbeddedResource Remove="Data\**" />
-		<EmbeddedResource Remove="obj\**" />
-		<EmbeddedResource Remove="Output\**" />
-	</ItemGroup>
-
-	<ItemGroup>
-		<None Remove="Data\**" />
-		<None Remove="obj\**" />
-		<None Remove="Output\**" />
-	</ItemGroup>
-
-	<ItemGroup>
-	  <PackageReference Include="Discord.Net" Version="3.7.2" />
-	</ItemGroup>
-
-	<ItemGroup>
-		<ProjectReference Include="..\PluginManager\PluginManager.csproj" />
-	</ItemGroup>
-
-	<Target Name="PostBuild" AfterTargets="PostBuildEvent">
-	  <Exec Command="xcopy /B /Y &quot;$(TargetDir)*.dll&quot; &quot;$(TargetDir)Libraries&quot;" />
-	</Target>
-
-</Project>

DiscordBot/DiscordBot.csproj

@@ -8,7 +8,7 @@
 		<StartupObject />
 		<SignAssembly>False</SignAssembly>
 		<IsPublishable>True</IsPublishable>
-		<AssemblyVersion>1.0.1.0</AssemblyVersion>
+		<AssemblyVersion>1.0.0.1</AssemblyVersion>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">

DiscordBot/Entry.cs

@@ -1,29 +0,0 @@
-using System;
-using System.IO;
-using System.Reflection;
-
-namespace DiscordBot
-{
-
-    public class Entry
-    {
-        [STAThread]
-        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/Program.cs

@@ -1,189 +1,62 @@
 using System;
-using System.Diagnostics;
+using System.Collections.Generic;
 using System.IO;
-using System.Reflection;
-using System.Threading;
+using System.Linq;
 using System.Threading.Tasks;
-
 using DiscordBot.Discord.Core;
-
 using PluginManager;
-using PluginManager.Database;
 using PluginManager.Items;
 using PluginManager.Online;
-using PluginManager.Online.Helpers;
 using PluginManager.Others;
 
-using Terminal.Gui;
-
-using OperatingSystem = PluginManager.Others.OperatingSystem;
-
 namespace DiscordBot;
 
 public class Program
 {
     private static bool loadPluginsOnStartup;
     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)
     {
-
+        Directory.CreateDirectory("./Data/Resources");
+        Directory.CreateDirectory("./Data/Plugins/Commands");
+        Directory.CreateDirectory("./Data/Plugins/Events");
         PreLoadComponents().Wait();
 
-        if (!Config.Variables.Exists("ServerID") || !Config.Variables.Exists("token") ||
-            Config.Variables.GetValue("token") == null ||
-            (Config.Variables.GetValue("token")?.Length != 70 && Config.Variables.GetValue("token")?.Length != 59) ||
-            !Config.Variables.Exists("prefix") || Config.Variables.GetValue("prefix") == null ||
-            Config.Variables.GetValue("prefix")?.Length != 1 ||
-            (args.Length == 1 && args[0] == "/reset"))
+        if (!Config.ContainsKey("token") || Config.GetValue<string>("token") == null || Config.GetValue<string>("token")?.Length != 70)
         {
-            Application.Init();
-            var top = Application.Top;
-            var win = new Window("Discord Bot Config - " + Assembly.GetExecutingAssembly().GetName().Version)
-            {
-                X = 0,
-                Y = 1,
-                Width = Dim.Fill(),
-                Height = Dim.Fill()
-            };
+            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");
 
-            top.Add(win);
+            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];
 
-            var labelInfo = new Label(
-                    "Configuration file not found or invalid. " +
-                    "Please fill the following fields to create a new configuration file."
-                )
-            {
-                X = Pos.Center(),
-                Y = 2
-            };
-
-
-            var labelToken = new Label("Please insert your token here: ")
-            {
-                X = 5,
-                Y = 5
-            };
-
-            var textFiledToken = new TextField("")
-            {
-                X = Pos.Left(labelToken) + labelToken.Text.Length + 2,
-                Y = labelToken.Y,
-                Width = 70
-            };
-
-            var labelPrefix = new Label("Please insert your prefix here: ")
-            {
-                X = 5,
-                Y = 8
-            };
-            var textFiledPrefix = new TextField("")
-            {
-                X = Pos.Left(labelPrefix) + labelPrefix.Text.Length + 2,
-                Y = labelPrefix.Y,
-                Width = 1
-            };
-
-            var labelServerid = new Label("Please insert your server id here (optional): ")
-            {
-                X = 5,
-                Y = 11
-            };
-            var textFiledServerID = new TextField("")
-            {
-                X = Pos.Left(labelServerid) + labelServerid.Text.Length + 2,
-                Y = labelServerid.Y,
-                Width = 18
-            };
-
-            var button = new Button("Submit")
-            {
-                X = Pos.Center() - 10,
-                Y = 16
-            };
-
-            var button2 = new Button("License")
-            {
-                X = Pos.Center() + 10,
-                Y = 16
-            };
-
-            var button3 = new Button("ⓘ")
-            {
-                X = Pos.Left(textFiledServerID) + 20,
-                Y = textFiledServerID.Y
-            };
-
-            Console.CancelKeyPress += (sender, e) => { top.Running = false; };
-
-            button.Clicked += () =>
-            {
-                var passMessage = "";
-                if (textFiledToken.Text.Length != 70 && textFiledToken.Text.Length != 59)
-                    passMessage += "Invalid token, ";
-                if (textFiledPrefix.Text.ContainsAny("0123456789/\\ ") || textFiledPrefix.Text.Length != 1)
-                    passMessage += "Invalid prefix, ";
-                if (textFiledServerID.Text.Length != 18 && textFiledServerID.Text.Length > 0)
-                    passMessage += "Invalid serverID";
-
-                if (passMessage != "")
-                {
-                    MessageBox.ErrorQuery("Discord Bot Settings",
-                                          "Failed to pass check. Invalid information given:\n" + passMessage, "Retry");
-                    return;
+            if (prefix == ' ' || char.IsDigit(prefix)) return;
+            Config.AddValueToVariables("prefix", prefix.ToString(), false);
         }
 
-
-                Config.Variables.Add("ServerID", (string)textFiledServerID.Text, true);
-                Config.Variables.Add("token", (string)textFiledToken.Text, true);
-                Config.Variables.Add("prefix", (string)textFiledPrefix.Text, true);
-
-                MessageBox.Query("Discord Bot Settings", "Successfully saved config !\nJust start the bot :D",
-                                 "Start :D");
-                top.Running = false;
-            };
-
-            button2.Clicked += async () =>
+        if (!Config.ContainsKey("prefix") || Config.GetValue<string>("prefix") == default)
         {
-                var license =
-                    await ServerCom.ReadTextFromURL(
-                        "https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/LICENSE.txt");
-                var ProductLicense =
-                    "Seth Discord Bot\n\nDeveloped by Wizzy#9181\nThis application can be used and modified by anyone. Plugin development for this application is also free and supported";
-                var r = MessageBox.Query("Discord Bot Settings", ProductLicense, "Close", "Read about libraries used");
-                if (r == 1)
-                {
-                    var i = 0;
-                    while (i < license.Count)
-                    {
-                        var print_message = license[i++] + "\n";
-                        for (; i < license.Count && !license[i].StartsWith("-----------"); i++)
-                            print_message += license[i] + "\n";
-                        if (print_message.Contains("https://"))
-                            print_message += "\n\nCTRL + Click on a link to open it";
-                        if (MessageBox.Query("Licenses", print_message, "Next", "Quit") == 1) break;
+            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);
         }
-                }
-            };
 
-            button3.Clicked += () =>
-            {
-                MessageBox.Query("Discord Bot Settings",
-                                 "Server ID can be found in Server settings => Widget => Server ID",
-                                 "Close");
-            };
-
-            win.Add(labelInfo, labelPrefix, labelServerid, labelToken);
-            win.Add(textFiledToken, textFiledPrefix, textFiledServerID, button3);
-            win.Add(button, button2);
-            Application.Run();
-            Application.Shutdown();
-        }
 
         HandleInput(args).Wait();
     }
@@ -191,26 +64,22 @@ public class Program
     /// <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
-        Settings.Variables.outputStream.WriteLine();
-        ConsoleCommandsHandler.ExecuteCommad("lp").Wait();
-#else
+        var consoleCommandsHandler = new ConsoleCommandsHandler(discordbooter.client);
         if (loadPluginsOnStartup) consoleCommandsHandler.HandleCommand("lp");
         if (listPluginsAtStartup) consoleCommandsHandler.HandleCommand("listplugs");
-#endif
+
+        Config.SaveConfig();
+
 
         while (true)
         {
+            Console.ForegroundColor = ConsoleColor.White;
             var cmd = Console.ReadLine();
-            if (!consoleCommandsHandler.HandleCommand(cmd!
-#if DEBUG
-                                                    , false
-#endif
-
-            ) && cmd.Length > 0)
-                Settings.Variables.outputStream.WriteLine("Failed to run command " + cmd);
+            if (!consoleCommandsHandler.HandleCommand(cmd))
+                Console.WriteLine("Failed to run command " + cmd);
         }
     }
 
@@ -218,59 +87,54 @@ 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 =
-            await ServerCom.ReadTextFromURL(
-                "https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/StartupMessage");
+        List<string> startupMessageList = await ServerCom.ReadTextFromFile("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/StartupMessage");
 
-        foreach (var message in startupMessageList)
-            Settings.Variables.outputStream.WriteLine(message);
+        foreach (var message in startupMessageList) Console.WriteLine(message);
 
-        Settings.Variables.outputStream.WriteLine(
-            $"Running on version: {Assembly.GetExecutingAssembly().GetName().Version}");
-        Settings.Variables.outputStream.WriteLine($"Git URL: {Settings.Variables.WebsiteURL}");
+        Console.WriteLine($"Running on version: {Config.GetValue<string>("Version") ?? System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()}");
+        Console.WriteLine($"Git URL: {Config.GetValue<string>("GitURL") ?? " Could not find Git URL"}");
 
-        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;
-
-        if (Config.Variables.Exists("LaunchMessage"))
-            Utilities.WriteColorText(Config.Variables.GetValue("LaunchMessage"));
-
-
-        Utilities.WriteColorText(
-            "Please note that the bot saves a backup save file every time you are using the shudown command (&ysd&c)");
-        Settings.Variables.outputStream.WriteLine("============================ LOG ============================");
+        Console.WriteLine($"============================ LOG ============================");
 
         try
         {
-            string token = "";
-#if DEBUG
+            var token  = Config.GetValue<string>("token");
+            var prefix = Config.GetValue<string>("prefix");
 
-            if (await Settings.sqlDatabase.TableExistsAsync("BetaTest"))
-            {
-                Settings.Variables.outputStream.WriteLine("Starting in DEBUG MODE");
-                token = await Settings.sqlDatabase.GetValueAsync("BetaTest", "VariableName", "Token", "Value");
-            }
-#else
-            token = Config.Variables.GetValue("token");
-#endif
-            var prefix = Config.Variables.GetValue("prefix");
             var discordbooter = new Boot(token, prefix);
             await discordbooter.Awake();
             return discordbooter;
         }
         catch (Exception ex)
         {
-            Settings.Variables.outputStream.WriteLine(ex);
+            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>
@@ -279,82 +143,116 @@ public class Program
     {
         var len = args.Length;
 
-        var b = await StartNoGui();
-        consoleCommandsHandler = new ConsoleCommandsHandler(b.client);
-
-        if (len > 0 && args[0] == "/remplug")
+        if (len == 3 && args[0] == "/download")
         {
-            var plugName = string.Join(' ', args, 1, args.Length - 1);
-            Settings.Variables.outputStream.WriteLine("Starting to remove " + plugName);
-            await ConsoleCommandsHandler.ExecuteCommad("remplug " + plugName);
-            loadPluginsOnStartup = true;
+            var url      = args[1];
+            var location = args[2];
+
+            await ServerCom.DownloadFileAsync(url, location);
+
+            return;
         }
 
-        if (len > 0 && args[0] == "/lp")
-            loadPluginsOnStartup = true;
+        if (len > 0 && (args.Contains("--cmd") || args.Contains("--args") || args.Contains("--nomessage")))
+        {
+            if (args.Contains("lp") || args.Contains("loadplugins")) loadPluginsOnStartup = true;
+            if (args.Contains("listplugs")) listPluginsAtStartup                          = true;
+            len = 0;
+        }
 
-        var mainThread = new Thread(() =>
+
+        if (len == 0 || (args[0] != "--exec" && args[0] != "--execute"))
         {
-            try
-            {
-                NoGUI();
+            var b = await StartNoGUI();
+            await NoGUI(b);
+            return;
         }
-            catch (IOException ex)
+
+
+        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)
         {
-                if (ex.Message == "No process is on the other end of the pipe." || (uint)ex.HResult == 0x800700E9)
+            Console.ForegroundColor = ConsoleColor.White;
+            Console.Write("> ");
+            var message = Console.ReadLine().Split(' ');
+
+            switch (message[0])
             {
-                    if (Config.Variables.Exists("LaunchMessage"))
-                        Config.Variables.Add("LaunchMessage",
-                                                   "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 !",
-                                                   false);
-                    Functions.WriteErrFile(ex.ToString());
+                case "--help":
+                case "-help":
+                    Console.ForegroundColor = ConsoleColor.DarkYellow;
+                    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;
             }
         }
-        });
-        mainThread.Start();
     }
 
     private static async Task PreLoadComponents()
     {
-        Settings.Variables.outputStream = Console.Out;
-        Settings.Variables.outputStream.WriteLine("Loading resources ...");
-        var main = new Utilities.ProgressBar(ProgressBarType.NO_END);
-        main.Start();
-        Directory.CreateDirectory("./Data/Resources");
-        Directory.CreateDirectory("./Data/Plugins");
-        Directory.CreateDirectory("./Data/PAKS");
-
-        Settings.sqlDatabase = new SqlDatabase(Functions.dataFolder + "SetDB.dat");
-
-        await Settings.sqlDatabase.Open();
-        await Config.Initialize();
-
-
-
-        if (await Config.Variables.ExistsAsync("DeleteLogsAtStartup"))
-            if (await Config.Variables.GetValueAsync("DeleteLogsAtStartup") == "true")
+        await Config.LoadConfig();
+        if (Config.ContainsKey("DeleteLogsAtStartup"))
+            if (Config.GetValue<bool>("DeleteLogsAtStartup"))
                 foreach (var file in Directory.GetFiles("./Output/Logs/"))
                     File.Delete(file);
-        var OnlineDefaultKeys =
-            await ServerCom.ReadTextFromURL(
-                "https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/SetupKeys");
+        List<string> OnlineDefaultKeys = await ServerCom.ReadTextFromFile("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/SetupKeys");
 
+        Config.PluginConfig.Load();
 
-        if (!await Config.Variables.ExistsAsync("Version"))
-            await Config.Variables.AddAsync("Version", Assembly.GetExecutingAssembly().GetName().Version.ToString(), false);
+        if (!Config.ContainsKey("Version"))
+            Config.AddValueToVariables("Version", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(), false);
         else
-            await Config.Variables.SetValueAsync("Version", Assembly.GetExecutingAssembly().GetName().Version.ToString());
-
+            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
             {
-                if (await Config.Variables.ExistsAsync(s[0])) await Config.Variables.SetValueAsync(s[0], s[1]);
-                else
-                    await Config.Variables.AddAsync(s[0], s[1], s[2].ToLower() == "true");
+                Config.GetAndAddValueToVariable(s[0], s[1], s[2].Equals("true", StringComparison.CurrentCultureIgnoreCase));
             }
             catch (Exception ex)
             {
@@ -362,80 +260,53 @@ public class Program
             }
         }
 
-
-        var onlineSettingsList =
-            await ServerCom.ReadTextFromURL(
-                "https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/OnlineData");
-        main.Stop("Loaded online settings. Loading updates ...");
+        List<string> onlineSettingsList = await ServerCom.ReadTextFromFile("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/OnlineData");
         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];
-                    if (!newVersion.Equals(await Config.Variables.GetValueAsync("Version")))
+                    string newVersion = s[1];
+                    if (!newVersion.Equals(Config.GetValue<string>("Version")))
                     {
-                        var nVer = new VersionString(newVersion.Substring(2));
-                        var cVer = new VersionString((await Config.Variables.GetValueAsync("Version")).Substring(2));
-                        if (cVer > nVer)
-                        {
-                            await Config.Variables.SetValueAsync("Version", "1." + cVer.ToShortString() + " (Beta)");
-                            break;
-                        }
+                        Console.WriteLine("A new version has been released on github page.");
+                        Console.WriteLine("Download the new version using the following link wrote in yellow");
+                        Console_Utilities.WriteColorText("&y" + Config.GetValue<string>("GitURL") + "&c");
 
-                        if (Functions.GetOperatingSystem() == OperatingSystem.WINDOWS)
-                        {
-                            var url =
-                                $"https://github.com/Wizzy69/SethDiscordBot/releases/download/v{newVersion}/net6.0.zip";
-                            Process.Start(".\\Updater\\Updater.exe",
-                                          $"{newVersion} {url} {Process.GetCurrentProcess().ProcessName}");
-                        }
-                        else
-                        {
-                            var url =
-                                $"https://github.com/Wizzy69/SethDiscordBot/releases/download/v{newVersion}/net6.0_linux.zip";
-                            Settings.Variables.outputStream.WriteLine("Downloading update ...");
-                            await ServerCom.DownloadFileNoProgressAsync(url, "./update.zip");
-                            await File.WriteAllTextAsync("Install.sh",
-                                                         "#!/bin/bash\nunzip -qq update.zip -d ./\nrm update.zip\nchmod +x SethDiscordBot\n./DiscordBot");
-                            Process.Start("Install.sh").WaitForExit();
-                            Environment.Exit(0);
-                        }
-                    }
+                        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");
 
-                    break;
-                case "UpdaterVersion":
-                    var updaternewversion = s[1];
-                    if (Functions.GetOperatingSystem() == OperatingSystem.LINUX)
-                        break;
+                        Console_Utilities.WriteColorText("&mCurrent Version: " + Config.GetValue<string>("Version") + "&c");
+                        Console_Utilities.WriteColorText("&gNew Version: " + newVersion + "&c");
 
-                    if (!await Config.Variables.ExistsAsync("UpdaterVersion"))
-                        await Config.Variables.AddAsync("UpdaterVersion", "0.0.0.0", false);
-                    if (await Config.Variables.GetValueAsync("UpdaterVersion") != updaternewversion ||
-                        !Directory.Exists("./Updater") ||
-                        !File.Exists("./Updater/Updater.exe"))
+                        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)
                         {
-                        Console.Clear();
-                        Settings.Variables.outputStream.WriteLine("Installing updater ...\nDo NOT close the bot during update !");
-                        var bar = new Utilities.ProgressBar(ProgressBarType.NO_END);
-                        bar.Start();
-                        await ServerCom.DownloadFileNoProgressAsync(
-                            "https://github.com/Wizzy69/installer/releases/download/release-1-discordbot/Updater.zip",
-                            "./Updater.zip");
-                        await Functions.ExtractArchive("./Updater.zip", "./", null,
-                                                       UnzipProgressType.PercentageFromTotalSize);
-                        await Config.Variables.SetValueAsync("UpdaterVersion", updaternewversion);
-                        File.Delete("Updater.zip");
-                        bar.Stop("Updater has been updated !");
-                        Console.Clear();
+                            await Task.Delay(1000);
+                            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");
+                        }
                     }
 
                     break;
             }
         }
-        Console.Clear();
+
+
+        Config.SaveConfig();
     }
 }

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/Config.cs

@@ -1,199 +1,169 @@
 using System;
+using PluginManager.Others;
+using System.IO;
+using System.Text.Json;
 using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading;
+using Newtonsoft.Json.Linq;
 
-using PluginManager.Online.Helpers;
-
-namespace PluginManager;
+namespace PluginManager
+{
+    internal class AppConfig
+    {
+        public Dictionary<string, object>? ApplicationVariables { get; set; }
+        public List<string>?               ProtectedKeyWords    { get; set; }
+    }
 
     public static class Config
     {
-    private static bool IsLoaded = false;
-    public static async Task Initialize()
+        public static class PluginConfig
         {
-        if (IsLoaded)
-            return;
+            public static List<Tuple<string, PluginType>> InstalledPlugins = new();
 
-        if (!await Settings.sqlDatabase.TableExistsAsync("Plugins"))
-            await Settings.sqlDatabase.CreateTableAsync("Plugins", "PluginName", "Version");
-        if (!await Settings.sqlDatabase.TableExistsAsync("Variables"))
-            await Settings.sqlDatabase.CreateTableAsync("Variables", "VarName", "Value", "ReadOnly");
-
-        IsLoaded = true;
-    }
-
-    public static class Variables
+            public static void Load()
             {
-        public static async Task<string> GetValueAsync(string VarName)
+                new Thread(LoadCommands).Start();
+                new Thread(LoadEvents).Start();
+            }
+
+            private static void LoadCommands()
             {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            return await Settings.sqlDatabase.GetValueAsync("Variables", "VarName", VarName, "Value");
-        }
-
-        public static string GetValue(string VarName)
+                string   cmd_path = "./Data/Plugins/Commands/";
+                string[] files    = Directory.GetFiles(cmd_path, $"*.{Loaders.PluginLoader.pluginCMDExtension}", SearchOption.AllDirectories);
+                foreach (var file in files)
+                    if (!file.Contains("PluginManager", StringComparison.InvariantCultureIgnoreCase))
                     {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            return Settings.sqlDatabase.GetValue("Variables", "VarName", VarName, "Value");
+                        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));
+                    }
             }
 
-
-        public static async Task SetValueAsync(string VarName, string Value)
+            private static void LoadEvents()
             {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-
-            if (await IsReadOnlyAsync(VarName))
-                throw new Exception($"Variable ({VarName}) is read only and can not be changed to {Value}");
-
-            await Settings.sqlDatabase.SetValueAsync("Variables", "VarName", VarName, "Value", Value);
-        }
-
-        public static void SetValue(string VarName, string Value)
+                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))
                         {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            if (IsReadOnly(VarName))
-                throw new Exception($"Variable ({VarName}) is read only and can not be changed to {Value}");
-            Settings.sqlDatabase.SetValue("Variables", "VarName", VarName, "Value", Value);
+                            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 async Task<bool> IsReadOnlyAsync(string VarName)
+            public static bool Contains(string pluginName)
             {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            return (await Settings.sqlDatabase.GetValueAsync("Variables", "VarName", VarName, "ReadOnly")).Equals("true", StringComparison.CurrentCultureIgnoreCase);
-        }
-
-        public static bool IsReadOnly(string VarName)
+                foreach (var tuple in InstalledPlugins)
                 {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            return (Settings.sqlDatabase.GetValue("Variables", "VarName", VarName, "ReadOnly")).Equals("true", StringComparison.CurrentCultureIgnoreCase);
+                    if (tuple.Item1 == pluginName) return true;
                 }
 
-        public static async Task SetReadOnlyAsync(string VarName, bool ReadOnly)
+                return false;
+            }
+
+            public static PluginType GetPluginType(string pluginName)
             {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            await Settings.sqlDatabase.SetValueAsync("Variables", "VarName", VarName, "ReadOnly", ReadOnly ? "true" : "false");
-        }
-
-        public static void SetReadOnly(string VarName, bool ReadOnly)
+                foreach (var tuple in InstalledPlugins)
                 {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            Settings.sqlDatabase.SetValue("Variables", "VarName", VarName, "ReadOnly", ReadOnly ? "true" : "false");
+                    if (tuple.Item1 == pluginName) return tuple.Item2;
                 }
 
-        public static async Task<bool> ExistsAsync(string VarName)
+                return PluginType.Unknown;
+            }
+        }
+
+        private static AppConfig? appConfig { get; set; }
+
+        public static bool AddValueToVariables<T>(string key, T value, bool isProtected)
         {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            return await Settings.sqlDatabase.KeyExistsAsync("Variables", "VarName", VarName);
+            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;
         }
 
-        public static bool Exists(string VarName)
+        public static void GetAndAddValueToVariable(string key, string value, bool isReadOnly)
         {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            return Settings.sqlDatabase.KeyExists("Variables", "VarName", VarName);
+            if (Config.ContainsKey(key)) return;
+            if (int.TryParse(value, out var intValue))
+                Config.AddValueToVariables(key, intValue, isReadOnly);
+            else if (bool.TryParse(value, out var boolValue))
+                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 async Task AddAsync(string VarName, string Value, bool ReadOnly = false)
+        public static T? GetValue<T>(string key)
         {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            if (await ExistsAsync(VarName))
+            if (!appConfig!.ApplicationVariables!.ContainsKey(key)) return default;
+            try
             {
-                await SetValueAsync(VarName, Value);
-                await SetReadOnlyAsync(VarName, ReadOnly);
-                return;
+                JsonElement element = (JsonElement)appConfig.ApplicationVariables[key];
+                return element.Deserialize<T>();
             }
-            await Settings.sqlDatabase.InsertAsync("Variables", VarName, Value, ReadOnly ? "true" : "false");
-        }
-
-        public static void Add(string VarName, string Value, bool ReadOnly = false)
+            catch
             {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            if (Exists(VarName))
+                return (T)appConfig.ApplicationVariables[key];
+            }
+        }
+
+        public static bool SetValue<T>(string key, T value)
         {
-                SetValue(VarName, Value);
-                SetReadOnly(VarName, ReadOnly);
-                return;
-            }
-            Settings.sqlDatabase.Insert("Variables", VarName, Value, ReadOnly ? "true" : "false");
+            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 static async Task RemoveKeyAsync(string VarName)
+        public static bool RemoveKey(string key)
         {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            await Settings.sqlDatabase.RemoveKeyAsync("Variables", "VarName", VarName);
+            if (key == "Version" || key == "token" || key == "prefix") return false;
+            appConfig!.ApplicationVariables!.Remove(key);
+            appConfig.ProtectedKeyWords!.Remove(key);
+            SaveConfig();
+            return true;
         }
 
-        public static void RemoveKey(string VarName)
+        public static async void SaveConfig()
         {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded");
-            Settings.sqlDatabase.RemoveKey("Variables", "VarName", VarName);
-        }
+            string path = Functions.dataFolder + "config.json";
+            await Functions.SaveToJsonFile<AppConfig>(path, appConfig!);
         }
 
-    public static class Plugins
+        public static async Task LoadConfig()
         {
-        public static async Task<string> GetVersionAsync(string pluginName)
+            string path = Functions.dataFolder + "config.json";
+            if (File.Exists(path))
             {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded yet");
-
-            string result = await Settings.sqlDatabase.GetValueAsync("Plugins", "PluginName", pluginName, "Version");
-            if (result is null)
-                return "0.0.0";
-
-            return result;
+                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 static string GetVersion(string pluginName)
-        {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded yet");
-
-            string result = Settings.sqlDatabase.GetValue("Plugins", "PluginName", pluginName, "Version");
-            if (result is null)
-                return "0.0.0";
-
-            return result;
-        }
-
-        public static async Task SetVersionAsync(string pluginName, VersionString version)
-        {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded yet");
-
-            if (!await Settings.sqlDatabase.KeyExistsAsync("Plugins", "PluginName", pluginName))
-            {
-                await Settings.sqlDatabase.InsertAsync("Plugins", pluginName, version.ToShortString());
-                return;
-            }
-            await Settings.sqlDatabase.SetValueAsync("Plugins", "PluginName", pluginName, "Version", version.ToShortString());
-        }
-
-        public static void SetVersion(string pluginName, VersionString version)
-        {
-            if (!IsLoaded)
-                throw new Exception("Config is not loaded yet");
-
-            if (!Settings.sqlDatabase.KeyExists("Plugins", "PluginName", pluginName))
-            {
-                Settings.sqlDatabase.Insert("Plugins", pluginName, version.ToShortString());
-                return;
-            }
-
-            Settings.sqlDatabase.SetValue("Plugins", "PluginName", pluginName, "Version", version.ToShortString());
-        }
+        public static bool ContainsValue<T>(T value) => appConfig!.ApplicationVariables!.ContainsValue(value!);
+        public static bool ContainsKey(string key)   => appConfig!.ApplicationVariables!.ContainsKey(key);
 
+        public static Dictionary<string, object> GetAllVariables() => new(appConfig!.ApplicationVariables!);
     }
 }

PluginManager/Database/SqlDatabase.cs

@@ -1,310 +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;
-
-        public SqlDatabase(string fileName)
-        {
-            if (!File.Exists(fileName))
-                SQLiteConnection.CreateFile(fileName);
-            ConnectionString = $"URI=file:{fileName}";
-            Connection = new SQLiteConnection(ConnectionString);
-        }
-
-        public async Task Open()
-        {
-            await Connection.OpenAsync();
-
-            //Console.WriteLine("Opened database successfully");
-        }
-
-        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();
-        }
-
-        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();
-
-        }
-
-        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();
-
-
-        }
-
-        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();
-
-
-        }
-
-
-        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;
-        }
-
-        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;
-
-        }
-
-
-        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}'");
-        }
-
-        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}'");
-        }
-
-
-        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}'");
-        }
-
-        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}'");
-        }
-
-        public async void Stop()
-        {
-            await Connection.CloseAsync();
-        }
-
-        public async Task AddColumnsToTableAsync(string tableName, string[] columns)
-        {
-
-            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} TEXT";
-                    await command.ExecuteNonQueryAsync();
-                }
-            }
-        }
-
-        public void AddColumnsToTable(string tableName, string[] columns)
-        {
-
-            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} TEXT";
-                    command.ExecuteNonQuery();
-                }
-            }
-
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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();
-
-        }
-
-        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();
-
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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;
-        }
-
-        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;
-        }
-    }
-}

PluginManager/Interfaces/DBCommand.cs

@@ -1,6 +1,5 @@
-using System.Collections.Generic;
-
-using Discord.Commands;
+using Discord.Commands;
+using Discord.WebSocket;
 
 namespace PluginManager.Interfaces;
 
@@ -12,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>
@@ -28,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="context">The disocrd Context</param>
-    void ExecuteServer(SocketCommandContext context)
-    {
-    }
-
-    /// <summary>
-    ///     The main body of the command. This is what is executed when user calls the command in DM
-    /// </summary>
-    /// <param name="context">The disocrd Context</param>
-    void ExecuteDM(SocketCommandContext context)
-    {
-    }
+    /// <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,
+                 SocketMessage        message,
+                 DiscordSocketClient  client,
+                 bool                 isDM);
 }

PluginManager/Interfaces/DBEvent.cs

@@ -7,12 +7,12 @@ 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

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

@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
-
 using Discord.WebSocket;
+using PluginManager.Others;
 
 namespace PluginManager.Items;
 
-public class Command
+internal class Command
 {
     /// <summary>
     ///     The author of the command
@@ -20,7 +20,10 @@ public class Command
     {
         Author = message.Author;
         var data = message.Content.Split(' ');
-        Arguments = data.Length > 1 ? new List<string>(string.Join(' ', data, 1, data.Length - 1).Split(' ')) : new List<string>();
+        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];
     }
@@ -43,8 +46,8 @@ public class Command
 
 public class ConsoleCommand
 {
-    public string CommandName { get; init; }
-    public string Description { get; init; }
-    public string Usage { get; init; }
-    public Action<string[]> Action { get; init; }
+        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

@@ -3,52 +3,39 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Net.Http;
-using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
-
 using Discord.WebSocket;
-
-using PluginManager.Interfaces;
 using PluginManager.Loaders;
 using PluginManager.Online;
 using PluginManager.Others;
 
-using OperatingSystem = PluginManager.Others.OperatingSystem;
-
 namespace PluginManager.Items;
 
 public class ConsoleCommandsHandler
 {
-    private static readonly PluginsManager manager =
-        new("https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/Plugins.txt");
-
-    private static readonly List<ConsoleCommand> commandList = new();
-
-
-    private static bool isDownloading;
-    private static bool pluginsLoaded;
+    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();
-
-
-        //Settings.Variables.outputStream.WriteLine("Initialized console command handler !");
+        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)
                 {
-                    Settings.Variables.outputStream.WriteLine("Available commands:");
-                    var items = new List<string[]>();
+                    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]" });
@@ -63,19 +50,19 @@ public class ConsoleCommandsHandler
                     }
 
                     items.Add(new[] { "-", "-", "-" });
-                    Utilities.FormatAndAlignTable(items, TableFormat.DEFAULT);
+                    Console_Utilities.FormatAndAlignTable(items);
                 }
                 else
                 {
                     foreach (var command in commandList)
                         if (command.CommandName == args[1])
                         {
-                            Settings.Variables.outputStream.WriteLine("Command description: " + command.Description);
-                            Settings.Variables.outputStream.WriteLine("Command execution format:" + command.Usage);
+                            Console.WriteLine("Command description: " + command.Description);
+                            Console.WriteLine("Command execution format:" + command.Usage);
                             return;
                         }
 
-                    Settings.Variables.outputStream.WriteLine("Command not found");
+                    Console.WriteLine("Command not found");
                 }
             }
         );
@@ -83,88 +70,44 @@ public class ConsoleCommandsHandler
 
         AddCommand("lp", "Load plugins", () =>
             {
-                if (pluginsLoaded)
-                    return;
+                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;
-                        Settings.Variables.outputStream.WriteLine("[CMD] Successfully loaded command : " + name);
-                    }
-
+                    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;
-                        if (exception is null)
-                            Settings.Variables.outputStream.WriteLine("An error occured while loading: " + name);
-                        else
-                            Settings.Variables.outputStream.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)
-                    {
+                    if (name == null || name.Length < 2) name = typeName;
                     Console.ForegroundColor = ConsoleColor.Green;
-                        Settings.Variables.outputStream.WriteLine("[EVENT] Successfully loaded event : " + name);
-                    }
-                    else
-                    {
-                        Console.ForegroundColor = ConsoleColor.Red;
-                        Settings.Variables.outputStream.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;
-                        Settings.Variables.outputStream.WriteLine("[SLASH] Successfully loaded command : " + name);
-                    }
+                        Console.WriteLine("[EVENT] Successfully loaded event : " + name);
                     else
-                    {
+                        Console.WriteLine("[EVENT] Failed to load event : " + name + " because " + exception!.Message);
                     Console.ForegroundColor = ConsoleColor.Red;
-                        Settings.Variables.outputStream.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", () => { manager.ListAvailablePlugins().Wait(); });
+        AddCommand("listplugs", "list available plugins", async () => { await manager.ListAvailablePlugins(); });
 
         AddCommand("dwplug", "download plugin", "dwplug [name]", async args =>
             {
-                isDownloading = true;
                 if (args.Length == 1)
                 {
-                    isDownloading = false;
-                    Settings.Variables.outputStream.WriteLine("Please specify plugin name");
+                    Console.WriteLine("Please specify plugin name");
                     return;
                 }
 
-                var name = string.Join(' ', args, 1, args.Length - 1);
+                var name = args.MergeStrings(1);
                 // info[0] = plugin type
                 // info[1] = plugin link
                 // info[2] = if others are required, or string.Empty if none
@@ -173,269 +116,139 @@ public class ConsoleCommandsHandler
                 {
                     if (name == "")
                     {
-                        isDownloading = false;
-                        Utilities.WriteColorText("Name is invalid");
+                        Console_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 !");
+                    Console_Utilities.WriteColorText($"Failed to find plugin &b{name} &c!" +
+                                                     " Use &glistplugs &ccommand to display all available plugins !"
+                    );
                     return;
                 }
 
                 string path;
-                if (info[0] == "Plugin")
-                    path = "./Data/Plugins/" + name + ".dll";
+                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]}";
-
-                if (OperatingSystem.WINDOWS == Functions.GetOperatingSystem())
-                {
                 await ServerCom.DownloadFileAsync(info[1], path);
-                }
-                else if (OperatingSystem.LINUX == Functions.GetOperatingSystem())
-                {
-                    var bar = new Utilities.ProgressBar(ProgressBarType.NO_END);
-                    bar.Start();
-                    await ServerCom.DownloadFileNoProgressAsync(info[1], path);
-                    bar.Stop("Plugin Downloaded !");
-                }
+                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));
 
 
-                Settings.Variables.outputStream.WriteLine("\n");
+                Console.WriteLine("\n");
 
                 // check requirements if any
 
                 if (info.Length == 3 && info[2] != string.Empty && info[2] != null)
                 {
-                    Settings.Variables.outputStream.WriteLine($"Downloading requirements for plugin : {name}");
+                    Console.WriteLine($"Downloading requirements for plugin : {name}");
 
-                    var lines = await ServerCom.ReadTextFromURL(info[2]);
+                    var lines = await ServerCom.ReadTextFromFile(info[2]);
 
                     foreach (var line in lines)
                     {
-                        if (!(line.Length > 0 && line.Contains(",")))
-                            continue;
+                        if (!(line.Length > 0 && line.Contains(","))) continue;
                         var split = line.Split(',');
-                        Settings.Variables.outputStream.WriteLine($"\nDownloading item: {split[1]}");
-                        if (File.Exists("./" + split[1])) File.Delete("./" + split[1]);
-                        if (OperatingSystem.WINDOWS == Functions.GetOperatingSystem())
-                        {
+                        Console.WriteLine($"\nDownloading item: {split[1]}");
                         await ServerCom.DownloadFileAsync(split[0], "./" + split[1]);
-                        }
-                        else if (OperatingSystem.LINUX == Functions.GetOperatingSystem())
-                        {
-                            var bar = new Utilities.ProgressBar(ProgressBarType.NO_END);
-                            bar.Start();
-                            await ServerCom.DownloadFileNoProgressAsync(split[0], "./" + split[1]);
-                            bar.Stop("Item downloaded !");
-                        }
+                        Console.WriteLine();
 
-                        Settings.Variables.outputStream.WriteLine();
-                        if (split[0].EndsWith(".pak"))
+                        if (split[0].EndsWith(".zip"))
                         {
-                            File.Move("./" + split[1], "./Data/PAKS/" + split[1], true);
+                            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);
                                                }
-                        else if (split[0].EndsWith(".zip") || split[0].EndsWith(".pkg"))
-                        {
-                            Settings.Variables.outputStream.WriteLine($"Extracting {split[1]} ...");
-                            var bar = new Utilities.ProgressBar(
-                                ProgressBarType.NO_END);
-                            bar.Start();
-                            await Functions.ExtractArchive("./" + split[1], "./", null,
-                                                           UnzipProgressType.PercentageFromTotalSize);
-                            bar.Stop("Extracted");
-                            Settings.Variables.outputStream.WriteLine("\n");
+                                           }
+                                       ).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]);
                         }
                     }
 
-                    Settings.Variables.outputStream.WriteLine();
+                    Console.WriteLine();
                 }
-
-                var ver = await ServerCom.GetVersionOfPackageFromWeb(name);
-                if (ver is null) throw new Exception("Incorrect version");
-                await Config.Plugins.SetVersionAsync(name, ver);
-
-                isDownloading = false;
             }
         );
 
 
         AddCommand("value", "read value from VariableStack", "value [key]",args =>
             {
-                if (args.Length != 2)
-                    return;
-                if (!Config.Variables.Exists(args[1]))
-                    return;
+                if (args.Length != 2) return;
+                if (!Config.ContainsKey(args[1])) return;
 
-                var data = Config.Variables.GetValue(args[1]);
-                Settings.Variables.outputStream.WriteLine($"{args[1]} => {data}");
+                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;
+                if (args.Length < 4) return;
                 var key        = args[1];
                 var value      = args[2];
                 var isReadOnly = args[3].Equals("true", StringComparison.CurrentCultureIgnoreCase);
 
                 try
                 {
-                    Config.Variables.Add(key, value, isReadOnly);
-                    Settings.Variables.outputStream.WriteLine($"Updated config file with the following command: {args[1]} => {value}");
+                    Config.GetAndAddValueToVariable(key, value, isReadOnly);
+                    Console.WriteLine($"Updated config file with the following command: {args[1]} => {value}");
                 }
                 catch (Exception ex)
                 {
-                    Settings.Variables.outputStream.WriteLine(ex.ToString());
+                    Console.WriteLine(ex.ToString());
                 }
             }
         );
 
         AddCommand("remv", "remove variable from system variables", "remv [key]", args =>
             {
-                if (args.Length < 2)
-                    return;
-                Config.Variables.RemoveKey(args[1]);
+                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;
-                var bar = new Utilities.ProgressBar(ProgressBarType.NO_END);
-
-                bar.Start();
-                bar.Stop("Saved config !");
-                Settings.Variables.outputStream.WriteLine();
-                Settings.sqlDatabase.Stop();
+                if (client is null) return;
                 await client.StopAsync();
                 await client.DisposeAsync();
-
-                await Task.Delay(1000);
+                Config.SaveConfig();
                 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);
-                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());
-
-                var types = asmb.GetTypes();
-                foreach (var type in types)
-                    if (type.IsClass && typeof(DBEvent).IsAssignableFrom(type))
-                    {
-                        var instance = (DBEvent)Activator.CreateInstance(type);
-                        instance.Start(this.client);
-                        Settings.Variables.outputStream.WriteLine($"[EVENT] Loaded external {type.FullName}!");
-                    }
-                    else if (type.IsClass && typeof(DBCommand).IsAssignableFrom(type))
-                    {
-                        var instance = (DBCommand)Activator.CreateInstance(type);
-                        Settings.Variables.outputStream.WriteLine($"[CMD] Instance: {type.FullName} loaded !");
-                    }
-            }
-            catch (Exception ex)
-            {
-                Settings.Variables.outputStream.WriteLine(ex.Message);
-            }
-        });
-
-        AddCommand("remplug", "Remove a plugin", "remplug [plugName]", async args =>
-        {
-            if (args.Length <= 1) return;
-
-            isDownloading = true;
-            var plugName = string.Join(' ', args, 1, args.Length - 1);
-            if (pluginsLoaded)
-            {
-                if (Functions.GetOperatingSystem() == OperatingSystem.WINDOWS)
-                {
-                    Process.Start("DiscordBot.exe", $"/remplug {plugName}");
-                    await Task.Delay(100);
-                    Environment.Exit(0);
-                }
-                else
-                {
-                    Process.Start("./DiscordBot", $"/remplug {plugName}");
-                    await Task.Delay(100);
-                    Environment.Exit(0);
-                }
-
-                isDownloading = false;
-                return;
-            }
-
-
-            var location = $"./Data/Plugins/{plugName}.dll";
-
-            if (!File.Exists(location))
-            {
-                Settings.Variables.outputStream.WriteLine("The plugin does not exist");
-                return;
-            }
-
-            File.Delete(location);
-
-            Settings.Variables.outputStream.WriteLine("Removed the plugin DLL. Checking for other files ...");
-
-            var info = await manager.GetPluginLinkByName(plugName);
-            if (info[2] != string.Empty)
-            {
-                var lines = await ServerCom.ReadTextFromURL(info[2]);
-                foreach (var line in lines)
-                {
-                    if (!(line.Length > 0 && line.Contains(",")))
-                        continue;
-                    var split = line.Split(',');
-                    if (File.Exists("./" + split[1]))
-                        File.Delete("./" + split[1]);
-
-
-                    Settings.Variables.outputStream.WriteLine("Removed: " + split[1]);
-                }
-
-                if (Directory.Exists($"./Data/Plugins/{plugName}"))
-                    Directory.Delete($"./Data/Plugins/{plugName}", true);
-
-                if (Directory.Exists(plugName))
-                    Directory.Delete(plugName, true);
-            }
-
-            isDownloading = false;
-            Settings.Variables.outputStream.WriteLine(plugName + " has been successfully deleted !");
-        });
-
-        AddCommand("reload", "Reload the bot with all plugins", () =>
-        {
-            if (Functions.GetOperatingSystem() == OperatingSystem.WINDOWS)
-            {
-                Process.Start("DiscordBot.exe", "lp");
-                HandleCommand("sd");
-            }
-            else
-            {
-                Process.Start("./DiscordBot", "lp");
-                HandleCommand("sd");
-            }
-        });
-
-        //AddCommand("");
-
         //Sort the commands by name
         commandList.Sort((x, y) => x.CommandName.CompareTo(y.CommandName));
     }
@@ -443,9 +256,14 @@ public class ConsoleCommandsHandler
     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 });
+        {
+            CommandName = command,
+            Description = description,
+            Action      = action,
+            Usage       = usage
+        });
         Console.ForegroundColor = ConsoleColor.White;
-        Utilities.WriteColorText($"Command &r{command} &cadded to the list of commands");
+        Console_Utilities.WriteColorText($"Command &r{command} &cadded to the list of commands");
     }
 
     public static void AddCommand(string command, string description, Action action)
@@ -460,7 +278,7 @@ public class ConsoleCommandsHandler
 
     public static bool CommandExists(string command)
     {
-        return GetCommand(command) is not null;
+        return !(GetCommand(command) is null);
     }
 
     public static ConsoleCommand? GetCommand(string command)
@@ -468,20 +286,8 @@ public class ConsoleCommandsHandler
         return commandList.FirstOrDefault(t => t.CommandName == command);
     }
 
-    public static async Task ExecuteCommad(string command)
-    {
-        var args = command.Split(' ');
-        foreach (var item in commandList.ToList())
-            if (item.CommandName == args[0])
-            {
-                item.Action.Invoke(args);
-                while (isDownloading) await Task.Delay(1000);
-            }
-    }
-
     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])
@@ -489,18 +295,16 @@ public class ConsoleCommandsHandler
                 if (removeCommandExecution)
                 {
                     Console.SetCursorPosition(0, Console.CursorTop - 1);
-                    for (var i = 0; i < command.Length + 30; i++)
-                        Settings.Variables.outputStream.Write(" ");
+                    for (int i = 0; i < command.Length; i++) Console.Write(" ");
                     Console.SetCursorPosition(0, Console.CursorTop);
                 }
 
-                Settings.Variables.outputStream.WriteLine();
+                Console.WriteLine();
                 item.Action(args);
-
                 return true;
             }
 
         return false;
-        //Settings.Variables.outputStream.WriteLine($"Executing: {args[0]} with the following parameters: {args.MergeStrings(1)}");
+        //Console.WriteLine($"Executing: {args[0]} with the following parameters: {args.MergeStrings(1)}");
     }
 }

PluginManager/Loaders/Loader.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
-
 using PluginManager.Others;
 
 namespace PluginManager.Loaders;
@@ -29,6 +28,11 @@ internal class Loader<T>
     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;
@@ -53,7 +57,7 @@ internal class Loader<T>
                     Exception  = null,
                     TypeName   = nameof(T),
                     IsLoaded   = false,
-                    PluginName = new FileInfo(file).Name.Split('.')[0],
+                    PluginName = file,
                     Plugin     = null
                 };
                 FileLoaded.Invoke(args);
@@ -90,14 +94,7 @@ internal class Loader<T>
                 }
                 catch (Exception ex)
                 {
-                    if (PluginLoaded != null)
-                        PluginLoaded.Invoke(new LoaderArgs
-                        {
-                            Exception = ex,
-                            IsLoaded = false,
-                            PluginName = type.FullName,
-                            TypeName = nameof(T)
-                        });
+                    if (PluginLoaded != null) PluginLoaded.Invoke(new LoaderArgs { Exception = ex, IsLoaded = false, PluginName = type.FullName, TypeName = nameof(T) });
                 }
         }
         catch (Exception ex)
@@ -108,9 +105,4 @@ internal class Loader<T>
 
         return list;
     }
-
-
-    internal delegate void FileLoadedEventHandler(LoaderArgs args);
-
-    internal delegate void PluginLoadedEventHandler(LoaderArgs args);
 }

PluginManager/Loaders/LoaderV2.cs

@@ -1,127 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-
-using PluginManager.Interfaces;
-using PluginManager.Others;
-
-namespace PluginManager.Loaders
-{
-    internal class LoaderV2
-    {
-        internal LoaderV2(string path, string extension)
-        {
-            this.path = 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)
-            {
-                Assembly.LoadFrom(file);
-                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)
-            {
-                Functions.WriteErrFile(ex.ToString());
-
-                return null;
-            }
-            return null;
-        }
-
-    }
-}

PluginManager/Loaders/PluginLoader.cs

@@ -1,14 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-
-using Discord;
 using Discord.WebSocket;
-
 using PluginManager.Interfaces;
-using PluginManager.Online;
-using PluginManager.Online.Updates;
 using PluginManager.Others;
 
 namespace PluginManager.Loaders;
@@ -19,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 pluginExtension = "dll";
+    internal const   string              pluginCMDExtension = "dll";
+    internal const   string              pluginEVEExtension = "dll";
     private readonly DiscordSocketClient _client;
 
     /// <summary>
@@ -36,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>
@@ -61,91 +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; }
-
     /// <summary>
     ///     The main mathod that is called to load all events
     /// </summary>
-    public async void LoadPlugins()
+    public void LoadPlugins()
     {
-        //Check for updates in commands
-        foreach (var file in Directory.GetFiles("./Data/Plugins/", $"*.{pluginExtension}",
-                                                SearchOption.AllDirectories))
-            await Task.Run(async () =>
-            {
-                var name = new FileInfo(file).Name.Split('.')[0];
-                var version = await ServerCom.GetVersionOfPackageFromWeb(name);
-                if (version is null)
-                    return;
-                if (Config.Plugins.GetVersion(name) is not null)
-                    Config.Plugins.SetVersion(name, version);
-
-                if (await PluginUpdater.CheckForUpdates(name))
-                    await PluginUpdater.Download(name);
-            });
-
-
-        //Load all plugins
-
         Commands = new List<DBCommand>();
         Events   = new List<DBEvent>();
-        SlashCommands = new List<DBSlashCommand>();
 
         Functions.WriteLogFile("Starting plugin loader ... Client: " + _client.CurrentUser.Username);
-        Settings.Variables.outputStream.WriteLine("Loading plugins");
+        Console.WriteLine("Loading plugins");
 
-        var loader = new LoaderV2("./Data/Plugins", "dll");
-        loader.FileLoaded += (args) => Functions.WriteLogFile($"{args.PluginName} file Loaded");
-        loader.PluginLoaded += Loader_PluginLoaded;
-        var res = loader.Load();
-        Events = res.Item1;
-        Commands = res.Item2;
-        SlashCommands = res.Item3;
+        var commandsLoader = new Loader<DBCommand>(pluginCMDFolder, pluginCMDExtension);
+        var eventsLoader   = new Loader<DBEvent>(pluginEVEFolder, pluginEVEExtension);
+
+        commandsLoader.FileLoaded   += OnCommandFileLoaded;
+        commandsLoader.PluginLoaded += OnCommandLoaded;
+
+        eventsLoader.FileLoaded   += EventFileLoaded;
+        eventsLoader.PluginLoaded += OnEventLoaded;
+
+        Commands = commandsLoader.Load();
+        Events   = eventsLoader.Load();
     }
 
-    private async void Loader_PluginLoaded(LoaderArgs args)
+    private void EventFileLoaded(LoaderArgs e)
     {
-        // Settings.Variables.outputStream.WriteLine(args.TypeName);
-        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);
+        if (e.IsLoaded) Functions.WriteLogFile($"[EVENT] Event from file [{e.PluginName}] has been successfully created !");
+    }
 
-                    onEVELoad?.Invoke(((DBEvent)args.Plugin!).Name, args.TypeName!, args.IsLoaded, args.Exception);
-                }
-                catch (Exception ex)
+    private void OnCommandFileLoaded(LoaderArgs e)
     {
-                    Settings.Variables.outputStream.WriteLine(ex.ToString());
-                    Settings.Variables.outputStream.WriteLine("Plugin: " + args.PluginName);
-                    Settings.Variables.outputStream.WriteLine("Type: " + args.TypeName);
-                    Settings.Variables.outputStream.WriteLine("IsLoaded: " + args.IsLoaded);
+        if (e.IsLoaded) Functions.WriteLogFile($"[CMD] Command from file [{e.PluginName}] has been successfully loaded !");
     }
-                break;
-            case "DBSlashCommand":
-                if (args.IsLoaded)
+
+    private void OnEventLoaded(LoaderArgs e)
     {
-                    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;
-                    //Settings.Variables.outputStream.WriteLine("Loaded " + slash.Name);
-                    onSLSHLoad?.Invoke(((DBSlashCommand)args.Plugin!).Name, args.TypeName, args.IsLoaded, args.Exception);
-                    await _client.CreateGlobalApplicationCommandAsync(builder.Build());
+        if (e.IsLoaded) ((DBEvent)e.Plugin!).Start(_client);
 
+        onEVELoad?.Invoke(((DBEvent)e.Plugin!).name, e.TypeName!, e.IsLoaded, e.Exception);
+    }
 
-                }
-                break;
-        }
+    private void OnCommandLoaded(LoaderArgs e)
+    {
+        onCMDLoad?.Invoke(((DBCommand)e.Plugin!).Command, e.TypeName!, e.IsLoaded, e.Exception);
     }
 }

PluginManager/Online/Helpers/OnlineFunctions.cs

@@ -1,12 +1,12 @@
 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>
@@ -19,21 +19,20 @@ internal static class OnlineFunctions
         /// <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)
+            IProgress<float>? progress = null, IProgress<long>? downloadedBytes = null, CancellationToken cancellation = default)
         {
-        using (var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellation))
+            using (var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
             {
                 var contentLength = response.Content.Headers.ContentLength;
 
-            using (var download = await response.Content.ReadAsStreamAsync(cancellation))
+                using (var download = await response.Content.ReadAsStreamAsync())
                 {
+
                     // Ignore progress reporting when no progress reporter was 
                     // passed or when the content length is unknown
                     if (progress == null || !contentLength.HasValue)
                     {
-                    await download.CopyToAsync(destination, cancellation);
+                        await download.CopyToAsync(destination);
                         return;
                     }
 
@@ -42,11 +41,9 @@ internal static class OnlineFunctions
                     {
                         progress.Report((float)totalBytes / contentLength.Value * 100);
                         downloadedBytes?.Report(totalBytes);
-                    }
-                );
-
+                    });
                     // Use extension method to report progress while downloading
-                await download.CopyToOtherStreamAsync(destination, bufferSize, relativeProgress, cancellation);
+                    await download.CopyToOtherStreamAsync(destination, 81920, relativeProgress, cancellation);
                     progress.Report(1);
                 }
             }
@@ -60,7 +57,13 @@ internal static class OnlineFunctions
         /// <returns></returns>
         internal static async Task<string> DownloadStringAsync(string url, CancellationToken cancellation = default)
         {
-        using var client = new HttpClient();
-        return await client.GetStringAsync(url, cancellation);
+            using (var client = new HttpClient())
+            {
+                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;
@@ -33,21 +30,20 @@ public class PluginsManager
     {
         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      len    = lines.Length;
-            string[] titles = { "Name", "Description", "Type", "Version" };
-            data.Add(new[] { "-", "-", "-", "-" });
+            string[] titles = { "Name", "Description", "Plugin Type", "Libraries", "Installed" };
+            data.Add(new[] { "-", "-", "-", "-", "-" });
             data.Add(titles);
-            data.Add(new[] { "-", "-", "-", "-" });
+            data.Add(new[] { "-", "-", "-", "-", "-" });
             for (var i = 0; i < len; i++)
             {
-                if (lines[i].Length <= 2)
-                    continue;
+                if (lines[i].Length <= 2) continue;
                 var content = lines[i].Split(',');
                 var display = new string[titles.Length];
                 if (op == OperatingSystem.WINDOWS)
@@ -57,9 +53,15 @@ public class PluginsManager
                         display[0] = content[0];
                         display[1] = content[1];
                         display[2] = content[2];
-                        display[3] =
-                            (await ServerCom.GetVersionOfPackageFromWeb(content[0]) ?? new VersionString("0.0.0"))
-                           .ToShortString();
+                        if (content.Length == 6 && (content[5] != null || content[5].Length > 2))
+                            display[3] = ((await ServerCom.ReadTextFromFile(content[5])).Count + 1).ToString();
+
+                        else
+                            display[3] = "1";
+                        if (Config.PluginConfig.Contains(content[0]) || Config.PluginConfig.Contains(content[0]))
+                            display[4] = "✓";
+                        else
+                            display[4] = "X";
                         data.Add(display);
                     }
                 }
@@ -70,21 +72,23 @@ public class PluginsManager
                         display[0] = content[0];
                         display[1] = content[1];
                         display[2] = content[2];
-                        display[3] =
-                            (await ServerCom.GetVersionOfPackageFromWeb(content[0]) ?? new VersionString("0.0.0"))
-                           .ToShortString();
+                        if (content.Length == 6 && (content[5] != null || content[5].Length > 2)) display[3] = ((await ServerCom.ReadTextFromFile(content[5])).Count + 1).ToString();
+                        if (Config.PluginConfig.Contains(content[0]) || Config.PluginConfig.Contains(content[0]))
+                            display[4] = "✓";
+                        else
+                            display[4] = "X";
                         data.Add(display);
                     }
                 }
             }
 
-            data.Add(new[] { "-", "-", "-", "-" });
+            data.Add(new[] { "-", "-", "-", "-", "-" });
 
-            Utilities.FormatAndAlignTable(data, TableFormat.CENTER_EACH_COLUMN_BASED);
+            Console_Utilities.FormatAndAlignTable(data);
         }
         catch (Exception exception)
         {
-            Settings.Variables.outputStream.WriteLine("Failed to execute command: listplugs\nReason: " + exception.Message);
+            Console.WriteLine("Failed to execute command: listlang\nReason: " + exception.Message);
             Functions.WriteErrFile(exception.ToString());
         }
     }
@@ -98,7 +102,7 @@ public class PluginsManager
     {
         try
         {
-            var list = await ServerCom.ReadTextFromURL(PluginsLink);
+            var list  = await ServerCom.ReadTextFromFile(PluginsLink);
             var lines = list.ToArray();
             var len   = lines.Length;
             for (var i = 0; i < len; i++)
@@ -106,17 +110,15 @@ public class PluginsManager
                 var contents = lines[i].Split(',');
                 if (contents[0] == name)
                 {
-                    if (contents.Length == 6)
-                        return new[] { contents[2], contents[3], contents[5] };
-                    if (contents.Length == 5)
-                        return new[] { contents[2], contents[3], string.Empty };
+                    if (contents.Length == 6) return new[] { contents[2], contents[3], contents[5] };
+                    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)
         {
-            Settings.Variables.outputStream.WriteLine("Failed to execute command: listplugs\nReason: " + exception.Message);
+            Console.WriteLine("Failed to execute command: listplugs\nReason: " + exception.Message);
             Functions.WriteErrFile(exception.ToString());
         }
 

PluginManager/Online/ServerCom.cs

@@ -1,27 +1,26 @@
-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 PluginManager.Online.Helpers;
 using PluginManager.Others;
 
-namespace PluginManager.Online;
-
-public static class ServerCom
+namespace PluginManager.Online
 {
+    public class ServerCom
+    {
+
         /// <summary>
         /// 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)
+        public static async Task<List<string>> ReadTextFromFile(string link)
         {
-        var response = await OnlineFunctions.DownloadStringAsync(link);
-        var lines = response.Split('\n');
+            string response = await OnlineFunctions.DownloadStringAsync(link);
+            string[] lines = response.Split('\n');
             return lines.ToList();
         }
 
@@ -32,10 +31,9 @@ public static class ServerCom
         /// <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)
+        public static async Task DownloadFileAsync(string URL, string location, IProgress<float> progress, IProgress<long>? downloadedBytes = null)
         {
-        using (var client = new HttpClient())
+            using (var client = new System.Net.Http.HttpClient())
             {
                 client.Timeout = TimeSpan.FromMinutes(5);
 
@@ -54,21 +52,23 @@ public static class ServerCom
         /// <returns></returns>
         public static async Task DownloadFileAsync(string URL, string location)
         {
-        var isDownloading = true;
-        float c_progress = 0;
+            bool isDownloading   = true;
+            int  c_progress      = 0;
 
-        var pbar = new Utilities.ProgressBar(ProgressBarType.NORMAL) { Max = 100f, NoColor = true };
+            Console_Utilities.ProgressBar pbar = new Console_Utilities.ProgressBar { Max = 100, NoColor = true };
 
-        IProgress<float> progress = new Progress<float>(percent => { c_progress = percent; });
+            IProgress<float> progress = new Progress<float>(percent =>
+            {
+                c_progress = (int)percent;
+            });
 
 
-        var updateProgressBarTask = new Task(() =>
+            Task updateProgressBarTask = new Task(() =>
                 {
                     while (isDownloading)
                     {
                         pbar.Update(c_progress);
-                    if (c_progress == 100f)
-                        break;
+                        if (c_progress == 100) break;
                         Thread.Sleep(500);
                     }
                 }
@@ -78,37 +78,9 @@ public static class ServerCom
             await DownloadFileAsync(URL, location, progress);
 
 
-        c_progress = pbar.Max;
-        pbar.Update(100f);
+            c_progress = 100;
+            pbar.Update(100);
             isDownloading = false;
         }
-
-    public static async Task DownloadFileNoProgressAsync(string URL, string location)
-    {
-        IProgress<float> progress = new Progress<float>();
-        await DownloadFileAsync(URL, location, progress);
-    }
-
-    public static VersionString? GetVersionOfPackage(string pakName)
-    {
-        if (Config.Plugins.GetVersion(pakName) is null)
-            return null;
-        return new VersionString(Config.Plugins.GetVersion(pakName));
-    }
-
-    public static async Task<VersionString?> GetVersionOfPackageFromWeb(string pakName)
-    {
-        var url = "https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/Versions";
-        var data = await ReadTextFromURL(url);
-        foreach (var item in data)
-        {
-            if (item.StartsWith("#"))
-                continue;
-
-            string[] split = item.Split(',');
-            if (split[0] == pakName)
-                return new VersionString(split[1]);
-        }
-        return null;
     }
 }

PluginManager/Online/Updates/PluginUpdater.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using PluginManager.Items;
-using PluginManager.Others;
-
-namespace PluginManager.Online.Updates;
-
-public class PluginUpdater
-{
-    public static async Task<bool> CheckForUpdates(string pakName)
-    {
-        try
-        {
-            var webV  = await ServerCom.GetVersionOfPackageFromWeb(pakName);
-            var local = ServerCom.GetVersionOfPackage(pakName);
-
-            if (local is null) return true;
-            if (webV is null) return false;
-
-            if (webV == local) return false;
-            if (webV > local) return true;
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine(ex.Message);
-        }
-
-
-        return false;
-    }
-
-    public static async Task<Update> DownloadUpdateInfo(string pakName)
-    {
-        var url     = "https://raw.githubusercontent.com/Wizzy69/installer/discord-bot-files/Versions";
-        var info    = await ServerCom.ReadTextFromURL(url);
-        var version = await ServerCom.GetVersionOfPackageFromWeb(pakName);
-
-        if (version is null) return Update.Empty;
-        var update = new Update(pakName, string.Join('\n', info), version);
-        return update;
-    }
-
-    public static async Task Download(string pakName)
-    {
-        Utilities.WriteColorText("An update was found for &g" + pakName + "&c. Version: &r" +
-                                         (await ServerCom.GetVersionOfPackageFromWeb(pakName))?.ToShortString() +
-                                         "&c. Current Version: &y" +
-                                         ServerCom.GetVersionOfPackage(pakName)?.ToShortString());
-        await ConsoleCommandsHandler.ExecuteCommad("dwplug " + pakName);
-    }
-}

PluginManager/Online/Updates/Update.cs

@@ -1,34 +0,0 @@
-using System;
-using PluginManager.Online.Helpers;
-
-namespace PluginManager.Online.Updates;
-
-public class Update
-{
-    public static Update Empty = new(null, null, null);
-
-    private readonly bool isEmpty;
-
-    public VersionString newVersion;
-    public string        pakName;
-    public string        UpdateMessage;
-
-    public Update(string pakName, string updateMessage, VersionString newVersion)
-    {
-        this.pakName    = pakName;
-        UpdateMessage   = updateMessage;
-        this.newVersion = newVersion;
-
-        if (pakName is null && updateMessage is null && newVersion is null)
-            isEmpty = true;
-    }
-
-    public override string ToString()
-    {
-        if (isEmpty)
-            throw new Exception("The update is EMPTY. Can not print information about an empty update !");
-        return $"Package Name: {pakName}\n"         +
-               $"Update Message: {UpdateMessage}\n" +
-               $"Version: {newVersion}";
-    }
-}

PluginManager/Others/Console Utilities.cs

@@ -1,26 +1,63 @@
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 
-namespace PluginManager.Others;
-
-public static class Utilities
+namespace PluginManager.Others
 {
-    private static Dictionary<char, ConsoleColor> Colors = new()
+    public class Console_Utilities
     {
-                    { '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)
+        /// <summary>
+        /// Progress bar object
+        /// </summary>
+        public class ProgressBar
         {
-        return MathF.Abs(f - y) < 0.000001;
+            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        ");
+
+            }
         }
 
 
@@ -28,338 +65,92 @@ public static class Utilities
         /// 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)
+        public static void FormatAndAlignTable(List<string[]> data)
         {
-        if (format == TableFormat.CENTER_EACH_COLUMN_BASED)
-        {
-            var tableLine = '-';
-            var tableCross = '+';
-            var tableWall = '|';
+            char tableLine  = '-';
+            char tableCross = '+';
+            char tableWall  = '|';
 
-            var len = new int[data[0].Length];
+            int[] len = new int[data[0].Length];
             foreach (var line in data)
-                for (var i = 0; i < line.Length; i++)
+            {
+                for (int i = 0; i < line.Length; i++)
                     if (line[i].Length > len[i])
                         len[i] = line[i].Length;
+            }
 
 
-            foreach (var row in data)
+            foreach (string[] row in data)
             {
-                if (row[0][0] == tableLine)
-                    Settings.Variables.outputStream.Write(tableCross);
-                else
-                    Settings.Variables.outputStream.Write(tableWall);
-                for (var l = 0; l < row.Length; l++)
+                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 (var i = 0; i < len[l] + 4; ++i)
-                            Settings.Variables.outputStream.Write(tableLine);
+                        for (int i = 0; i < len[l] + 4; ++i)
+                            Console.Write(tableLine);
                     }
                     else if (row[l].Length == len[l])
                     {
-                        Settings.Variables.outputStream.Write("  ");
-                        Settings.Variables.outputStream.Write(row[l]);
-                        Settings.Variables.outputStream.Write("  ");
+                        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)
-                            Settings.Variables.outputStream.Write(" ");
-                        Settings.Variables.outputStream.Write(row[l]);
-                        for (var i = (len[l] + 4) / 2 + lenHalf + 1; i < len[l] + 4; ++i)
-                            Settings.Variables.outputStream.Write(" ");
+
+                        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)
-                            Settings.Variables.outputStream.Write(" ");
+                            Console.Write(" ");
                     }
 
-                    Settings.Variables.outputStream.Write(row[l][0] == tableLine ? tableCross : tableWall);
+                    if (row[l][0] == tableLine) Console.Write(tableCross);
+                    else Console.Write(tableWall);
+                }
+                Console.WriteLine(); //end line
+
+            }
         }
 
-                Settings.Variables.outputStream.WriteLine(); //end line
-            }
-
-            return;
-        }
-
-        if (format == TableFormat.CENTER_OVERALL_LENGTH)
+        public static void WriteColorText(string text, bool appendNewLine = true)
         {
-            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)
+            string[] words = text.Split(' ');
+            ConsoleColor fg = Console.ForegroundColor;
+            Dictionary<string, ConsoleColor> colors = new Dictionary<string, ConsoleColor>()
             {
-                Settings.Variables.outputStream.Write("\t");
-                if (row[0] == "-")
-                    Settings.Variables.outputStream.Write("+");
-                else
-                    Settings.Variables.outputStream.Write("|");
-
-                foreach (var s in row)
+                { "&g", ConsoleColor.Green },
+                { "&b", ConsoleColor.Blue },
+                { "&r", ConsoleColor.Red },
+                { "&m", ConsoleColor.Magenta },
+                { "&y", ConsoleColor.Yellow },
+                { "&c", fg }
+            };
+            foreach (string word in words)
             {
-                    if (s == "-")
+                if (word.Length >= 2)
                 {
-                        for (var i = 0; i < maxLen + 4; ++i)
-                            Settings.Variables.outputStream.Write("-");
-                    }
-                    else if (s.Length == maxLen)
-                    {
-                        Settings.Variables.outputStream.Write("  ");
-                        Settings.Variables.outputStream.Write(s);
-                        Settings.Variables.outputStream.Write("  ");
-                    }
-                    else
-                    {
-                        var lenHalf = s.Length / 2;
-                        for (var i = 0; i < div - lenHalf; ++i)
-                            Settings.Variables.outputStream.Write(" ");
-                        Settings.Variables.outputStream.Write(s);
-                        for (var i = div + lenHalf + 1; i < maxLen + 4; ++i)
-                            Settings.Variables.outputStream.Write(" ");
-                        if (s.Length % 2 == 0)
-                            Settings.Variables.outputStream.Write(" ");
+                    string prefix = word.Substring(0, 2);
+                    if (colors.ContainsKey(prefix))
+                        Console.ForegroundColor = colors[prefix];
                 }
 
-                    if (s == "-")
-                        Settings.Variables.outputStream.Write("+");
-                    else
-                        Settings.Variables.outputStream.Write("|");
+                string m = word;
+                foreach (var key in colors.Keys) { m = m.Replace(key, ""); }
+
+                Console.Write(m + " ");
+            }
+            if (appendNewLine)
+                Console.Write('\n');
+
+            Console.ForegroundColor = fg;
         }
 
-                Settings.Variables.outputStream.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] = " ";
-                    Settings.Variables.outputStream.Write(data[i][j]);
-                    for (var k = 0; k < widths[j] - data[i][j].Length + 1 + space_between_columns; k++)
-                        Settings.Variables.outputStream.Write(" ");
-                }
-
-                Settings.Variables.outputStream.WriteLine();
-            }
-
-            return;
-        }
-
-        throw new Exception("Unknown type of table");
-    }
-
-    public static void WriteColorText(string text, bool appendNewLineAtEnd = true)
-    {
-        if (Console.Out != Settings.Variables.outputStream)
-        {
-            Settings.Variables.outputStream.Write(text);
-            if (appendNewLineAtEnd)
-                Settings.Variables.outputStream.WriteLine();
-            return;
-        }
-        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
-            {
-                Settings.Variables.outputStream.Write(input[i]);
-            }
-
-        Console.ForegroundColor = initialForeGround;
-        if (appendNewLineAtEnd)
-            Settings.Variables.outputStream.WriteLine();
-    }
-
-
-    /// <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)
-        {
-            if (Settings.Variables.outputStream != Console.Out)
-                throw new Exception("This class (or function) can be used with console only. For UI please use another approach.");
-            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()
-        {
-            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++)
-                    Settings.Variables.outputStream.Write(" ");
-                Console.CursorLeft = 0;
-                Settings.Variables.outputStream.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;
-            Settings.Variables.outputStream.Write("[");
-            for (var i = 1; i <= position; i++)
-                Settings.Variables.outputStream.Write(" ");
-            Settings.Variables.outputStream.Write("<==()==>");
-            position += positive ? 1 : -1;
-            for (var i = position; i <= BarLength - 1 - (positive ? 0 : 2); i++)
-                Settings.Variables.outputStream.Write(" ");
-            Settings.Variables.outputStream.Write("] " + message);
-
-
-            if (position == BarLength - 1 || position == 1)
-                positive = !positive;
-        }
-
-        private void UpdateNoEnd()
-        {
-            Console.CursorLeft = 0;
-            Settings.Variables.outputStream.Write("[");
-            for (var i = 1; i <= position; i++)
-                Settings.Variables.outputStream.Write(" ");
-            Settings.Variables.outputStream.Write("<==()==>");
-            position += positive ? 1 : -1;
-            for (var i = position; i <= BarLength - 1 - (positive ? 0 : 2); i++)
-                Settings.Variables.outputStream.Write(" ");
-            Settings.Variables.outputStream.Write("]");
-
-
-            if (position == BarLength - 1 || position == 1)
-                positive = !positive;
-        }
-
-        private void UpdateNormal(float progress)
-        {
-            Console.CursorLeft = 0;
-            Settings.Variables.outputStream.Write("[");
-            Console.CursorLeft = BarLength;
-            Settings.Variables.outputStream.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++;
-                Settings.Variables.outputStream.Write("#");
-            }
-
-            for (var i = position; i < BarLength; i++)
-            {
-                Console.BackgroundColor = NoColor ? ConsoleColor.Black : ConsoleColor.DarkGray;
-                Console.CursorLeft = position++;
-                Settings.Variables.outputStream.Write(" ");
-            }
-
-            Console.CursorLeft = BarLength + 4;
-            Console.BackgroundColor = ConsoleColor.Black;
-            if (progress.CanAproximateTo(Max))
-                Settings.Variables.outputStream.Write(progress + " %      ✓");
-            else
-                Settings.Variables.outputStream.Write(MathF.Round(progress, 2) + " %       ");
-        }
     }
 }

PluginManager/Others/Enums.cs

@@ -1,14 +1,13 @@
-namespace PluginManager.Others;
+using PluginManager.Interfaces;
+
+namespace PluginManager.Others;
 
 /// <summary>
 ///     A list of operating systems
 /// </summary>
 public enum OperatingSystem
 {
-    WINDOWS,
-    LINUX,
-    MAC_OS,
-    UNKNOWN
+    WINDOWS, LINUX, MAC_OS, UNKNOWN
 }
 
 /// <summary>
@@ -16,47 +15,15 @@ public enum OperatingSystem
 /// </summary>
 public enum Error
 {
-    UNKNOWN_ERROR,
-    GUILD_NOT_FOUND,
-    STREAM_NOT_FOUND,
-    INVALID_USER,
-    INVALID_CHANNEL,
-    INVALID_PERMISSIONS
+    UNKNOWN_ERROR, GUILD_NOT_FOUND, STREAM_NOT_FOUND, INVALID_USER, INVALID_CHANNEL, INVALID_PERMISSIONS
 }
 
 /// <summary>
 ///     The output log type
 /// </summary>
-public enum OutputLogLevel
-{
-    NONE,
-    INFO,
-    WARNING,
-    ERROR,
-    CRITICAL
-}
+public enum OutputLogLevel { NONE, INFO, WARNING, ERROR, CRITICAL }
 
-public enum UnzipProgressType
-{
-    PercentageFromNumberOfFiles,
-    PercentageFromTotalSize
-}
-
-public enum TableFormat
-{
-    CENTER_EACH_COLUMN_BASED,
-    CENTER_OVERALL_LENGTH,
-    DEFAULT
-}
-
-public enum SaveType
-{
-    NORMAL,
-    BACKUP
-}
-
-public enum ProgressBarType
-{
-    NORMAL,
-    NO_END
-}
+/// <summary>
+/// Plugin Type
+/// </summary>
+public enum PluginType { Command, Event, Unknown }

PluginManager/Others/Functions.cs

@@ -1,21 +1,17 @@
-using System;
-using System.Collections.Generic;
+using System.IO.Compression;
 using System.IO;
-using System.IO.Compression;
-using System.Linq;
-using System.Runtime.InteropServices;
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json;
-using System.Threading;
+using System;
 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>
@@ -29,22 +25,17 @@ public static class Functions
         /// <summary>
         /// The location for all logs
         /// </summary>
-    public static readonly string logFolder = @"./Data/Output/Logs/";
+        public static readonly string logFolder = @"./Output/Logs/";
 
         /// <summary>
         /// The location for all errors
         /// </summary>
-    public static readonly string errFolder = @"./Data/Output/Errors/";
+        public static readonly string errFolder = @"./Output/Errors/";
 
         /// <summary>
         /// Archives folder
         /// </summary>
-    public static readonly string pakFolder = @"./Data/PAKS/";
-
-    /// <summary>
-    ///     Beta testing folder
-    /// </summary>
-    public static readonly string betaFolder = @"./Data/BetaTest/";
+        public static readonly string pakFolder = @"./Data/Resources/PAK/";
 
 
         /// <summary>
@@ -53,39 +44,32 @@ public static class Functions
         /// <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)
+        public static async Task<Stream?> ReadFromPakAsync(string FileName, string archFile)
         {
             archFile = pakFolder + archFile;
-        if (!File.Exists(archFile))
-            throw new Exception("Failed to load file !");
+            Directory.CreateDirectory(pakFolder);
+            if (!File.Exists(archFile)) throw new FileNotFoundException("Failed to load file !");
 
-        try
-        {
-            string textValue = null;
-            using (var fs = new FileStream(archFile, FileMode.Open))
-            using (var zip = new ZipArchive(fs, ZipArchiveMode.Read))
-            {
+            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)
-                        using (var s = entry.Open())
-                        using (var reader = new StreamReader(s))
             {
-                            textValue = await reader.ReadToEndAsync();
+                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;
         }
-        catch
-        {
-            await Task.Delay(100);
-            return await ReadFromPakAsync(FileName, archFile);
-        }
-    }
-
 
         /// <summary>
         /// Write logs to file
@@ -93,8 +77,8 @@ public static class Functions
         /// <param name="LogMessage">The message to be wrote</param>
         public static void WriteLogFile(string LogMessage)
         {
-        var logsPath = logFolder + $"{DateTime.Today.ToShortDateString().Replace("/", "-").Replace("\\", "-")} Log.txt";
-        Directory.CreateDirectory(logFolder);
+            string logsPath = logFolder + "Log.txt";
+            if (!Directory.Exists(logFolder)) Directory.CreateDirectory(logFolder);
             File.AppendAllText(logsPath, LogMessage + " \n");
         }
 
@@ -104,15 +88,30 @@ public static class Functions
         /// <param name="ErrMessage">The message to be wrote</param>
         public static void WriteErrFile(string ErrMessage)
         {
-        var errPath = errFolder +
-                      $"{DateTime.Today.ToShortDateString().Replace("/", "-").Replace("\\", "-")} Error.txt";
-        Directory.CreateDirectory(errFolder);
+            string errPath = errFolder + "Error.txt";
+            if (!Directory.Exists(errFolder)) Directory.CreateDirectory(errFolder);
             File.AppendAllText(errPath, ErrMessage + " \n");
         }
 
-    public static void WriteErrFile(this Exception ex)
+        /// <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)
         {
-        WriteErrFile(ex.ToString());
+            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>
@@ -121,15 +120,15 @@ public static class Functions
         /// <returns>An Operating system</returns>
         public static OperatingSystem GetOperatingSystem()
         {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) return OperatingSystem.WINDOWS;
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) return OperatingSystem.LINUX;
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) return OperatingSystem.MAC_OS;
+            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)
         {
-        var command = new Command(message);
+            Command command = new Command(message);
             return command.Arguments;
         }
 
@@ -145,18 +144,15 @@ public static class Functions
         /// <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)
+        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));
+            if (!destination.CanWrite) throw new ArgumentException("Destination stream is not writable", nameof(destination));
 
-        var buffer = new byte[bufferSize];
+            byte[] buffer         = new byte[bufferSize];
             long   totalBytesRead = 0;
             int    bytesRead;
             while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false)) != 0)
@@ -165,6 +161,7 @@ public static class Functions
                 totalBytesRead += bytesRead;
                 progress?.Report(totalBytesRead);
             }
+
         }
 
         /// <summary>
@@ -172,22 +169,19 @@ public static class Functions
         /// </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)
+        public static async Task ExtractArchive(string zip, string folder, IProgress<float> progress)
         {
-        Directory.CreateDirectory(folder);
-        using (var archive = ZipFile.OpenRead(zip))
+            if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);
+
+
+            using (ZipArchive archive = ZipFile.OpenRead(zip))
             {
-            if (type == UnzipProgressType.PercentageFromNumberOfFiles)
+                int totalZIPFiles  = archive.Entries.Count();
+                int currentZIPFile = 0;
+                foreach (ZipArchiveEntry entry in archive.Entries)
                 {
-                var totalZIPFiles = archive.Entries.Count();
-                var currentZIPFile = 0;
-                foreach (var entry in archive.Entries)
-                {
-                    if (entry.FullName.EndsWith("/")) // it is a folder
+                    if (entry.FullName.EndsWith("/"))
                         Directory.CreateDirectory(Path.Combine(folder, entry.FullName));
 
                     else
@@ -195,49 +189,41 @@ public static class Functions
                         {
                             entry.ExtractToFile(Path.Combine(folder, entry.FullName), true);
                         }
-                        catch (Exception ex)
+                        catch
                         {
-                            Settings.Variables.outputStream.WriteLine($"Failed to extract {entry.Name}. Exception: {ex.Message}");
                         }
 
                     currentZIPFile++;
                     await Task.Delay(10);
-                    if (progress != null)
                     progress.Report((float)currentZIPFile / totalZIPFiles * 100);
                 }
             }
-            else if (type == UnzipProgressType.PercentageFromTotalSize)
-            {
-                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
+
+        /// <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)
         {
-                        entry.ExtractToFile(Path.Combine(folder, entry.FullName), true);
-                        currentSize += (ulong)entry.CompressedLength;
-                    }
-                    catch (Exception ex)
+            List<string> units = new List<string>()
             {
-                        Settings.Variables.outputStream.WriteLine($"Failed to extract {entry.Name}. Exception: {ex.Message}");
+                "B",
+                "KB",
+                "MB",
+                "GB",
+                "TB"
+            };
+            int i = 0;
+            while (bytes >= 1024)
+            {
+                i++;
+                bytes /= 1024;
             }
 
-                    await Task.Delay(10);
-                    if (progress != null)
-                        progress.Report((float)currentSize / zipSize * 100);
-                }
-            }
-        }
+            return (bytes, units[i]);
         }
 
         /// <summary>
@@ -249,9 +235,9 @@ public static class Functions
         /// <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());
+            var s = File.OpenWrite(file);
+            await JsonSerializer.SerializeAsync(s, Data, typeof(T), new JsonSerializerOptions { WriteIndented = true });
+            s.Close();
         }
 
         /// <summary>
@@ -264,7 +250,8 @@ public static class Functions
         {
             Stream text;
             if (File.Exists(input))
-            text = new MemoryStream(await File.ReadAllBytesAsync(input));
+                text = File.Open(input, FileMode.OpenOrCreate);
+
             else
                 text = new MemoryStream(Encoding.ASCII.GetBytes(input));
             text.Position = 0;
@@ -273,6 +260,35 @@ public static class Functions
             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;
@@ -287,14 +303,5 @@ public static class Functions
             var data = jsonObject.RootElement.TryGetProperty(codeName, out element);
             return data;
         }
-
-    public static string CreateMD5(string input)
-    {
-        using (var md5 = MD5.Create())
-        {
-            var inputBytes = Encoding.ASCII.GetBytes(input);
-            var hashBytes = md5.ComputeHash(inputBytes);
-            return Convert.ToHexString(hashBytes);
-        }
     }
 }

PluginManager/PluginManager.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<PropertyGroup>
 		<TargetFramework>net6.0</TargetFramework>
@@ -17,8 +17,6 @@
 
 	<ItemGroup>
 		<PackageReference Include="Discord.Net" Version="3.7.2" />
-		<PackageReference Include="System.Data.SQLite" Version="1.0.116" />
-		<PackageReference Include="Terminal.Gui" Version="1.8.2" />
 	</ItemGroup>
 
 </Project>

PluginManager/Variables.cs

@@ -1,21 +0,0 @@
-using System.IO;
-
-using PluginManager.Database;
-
-namespace PluginManager
-{
-    public class Settings
-    {
-
-        public static class Variables
-        {
-            public static string WebsiteURL = "https://wizzy69.github.io/SethDiscordBot";
-            public static string UpdaterURL = "https://github.com/Wizzy69/installer/releases/download/release-1-discordbot/Updater.zip";
-
-            public static TextWriter outputStream;
-        }
-
-        public static SqlDatabase sqlDatabase;
-    }
-
-}

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
@@ -16,6 +17,10 @@ Plugin Types:
 1. Commands
 2. Events
 
+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.

SethDiscordBot.sln

@@ -1,49 +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
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MusicLibrary", "..\DiscordBotItems\Plugins\MusicLibrary\MusicLibrary.csproj", "{878DFE01-4596-4EBC-9651-0679598CE794}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SlashCommands", "..\DiscordBotItems\Plugins\SlashCommands\SlashCommands.csproj", "{C2D73BE8-997B-4A4A-8EA5-989BE33EE1DD}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LevelingSystem", "..\DiscordBotItems\Plugins\LevelingSystem\LevelingSystem.csproj", "{0138F343-BBB9-4D5F-B499-D9C2978BE9AA}"
-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
-		{878DFE01-4596-4EBC-9651-0679598CE794}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{878DFE01-4596-4EBC-9651-0679598CE794}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{878DFE01-4596-4EBC-9651-0679598CE794}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{878DFE01-4596-4EBC-9651-0679598CE794}.Release|Any CPU.Build.0 = Release|Any CPU
-		{C2D73BE8-997B-4A4A-8EA5-989BE33EE1DD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C2D73BE8-997B-4A4A-8EA5-989BE33EE1DD}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C2D73BE8-997B-4A4A-8EA5-989BE33EE1DD}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C2D73BE8-997B-4A4A-8EA5-989BE33EE1DD}.Release|Any CPU.Build.0 = Release|Any CPU
-		{0138F343-BBB9-4D5F-B499-D9C2978BE9AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0138F343-BBB9-4D5F-B499-D9C2978BE9AA}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0138F343-BBB9-4D5F-B499-D9C2978BE9AA}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0138F343-BBB9-4D5F-B499-D9C2978BE9AA}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	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