1.0.0

* Added settings folder which is created if it does not already exist. See the default parameters in autorun/src/configs/settings.toml
* Overview of settings added: Ability to hide console on startup, disable plugins, disable filesteal, disable logging, and change the name of generated filesteal folders
* Added examples in the /examples/ directory
* Added ``settings`` command which gives an overview of your current autorun settings

* Remove ``sautorun`` alias

The only things left to do for 1.0.0 were fix 32 bit (which is not possible without nightly) and make require work relatively. I think I'll push require to be changed in 1.1, there's too many changes to have in just betas, so here it is. 1.0.0

Fixes #36
Fixes #29

Author: thevurv

README.md

@@ -5,28 +5,28 @@
 ## Features
 * Dumping all lua scripts to ``C:\Users\<User>\autorun\lua_dumps\<ServerIP>\..``
 * Runtime lua loading through ``lua_run`` and ``lua_openscript`` in an external console
-* Supports both 32 and 64 bit branches (WARNING: See [#22](https://github.com/Vurv78/Autorun-rs/issues/22))
+* Supports both 32* and 64 bit branches (*See [#22](https://github.com/Vurv78/Autorun-rs/issues/22))
 * Running a script before autorun (``autorun.lua``), to detour and bypass any 'anticheats'
 * Scripthook, stop & run scripts before anything runs on you, gives information & functions to assist in a safe separate lua environment
 * File logging (to ``autorun/logs``)
+* Plugin system (``autorun/plugins``)
+* [Settings using TOML](autorun/src/configs/settings.toml)
 
 ## 🤔 Usage
 ### 🧩 Menu Plugin
 Autorun can also be used as a menu plugin / required from lua automatically from the menu state.
-1. [Get the DLL](#downloading)
-1. Put the ``gmsv_autorun_win<arch>.dll`` file into your ``garrysmod/lua/bin`` folder.
+1. Put [the dll](#⬇️-downloading) ``gmsv_autorun_win<arch>.dll`` file into your ``garrysmod/lua/bin`` folder.
 2. Add ``require("autorun")`` at the bottom of ``garrysmod/lua/menu/menu.lua``  
 **It will now run automatically when garrysmod loads at the menu.**
 
 ### 💉 Injecting
 The traditional (but more inconvenient) method to use this is to just inject it.
 1. Get an injector (Make sure it's compatible to inject 32/64 bit code depending on your use).  
-2. [Get the DLL](#downloading)
-3. Inject into gmod while you're in the menu
+2. Inject [the dll](#⬇️-downloading) into gmod while you're in the menu
 
 ## 📜 Scripthook
 Autorun features scripthook, which means we'll run your script before any other garrysmod script executes to verify if you want the code to run by running your own hook script.
-*This runs in a separate environment from ``_G``, so to modify globals, do ``_G.foo = bar*``
+*This runs in a separate environment from ``_G``, so to modify globals, do ``_G.foo = bar``
 
 Also note that if you are running in ``autorun.lua`` Functions like ``http.Fetch`` & ``file.Write`` won't exist.  
 Use their C counterparts (``HTTP`` and ``file.Open``)
@@ -37,55 +37,49 @@ __See an example project using the scripthook [here](https://github.com/Vurv78/S
 ```golo
 C:\Users\<User>\autorun
 ├── \autorun.lua # Runs *once* before autorun
-├── \hook.lua # Runs for every script (including init.lua, which triggers autorun.lua)
+├── \hook.lua # Runs for every script
 ├── \lua_dumps\ # Each server gets it's own folder named by its IP
-│   ├── \192.168.1.1\
-│   ├── \192.168.1.2\
-│   └── \241241.352.1.3\
-│   \logs\
+│   ├── \192.168.1.55_27015\
+│   └── \X.Y.Z.W_PORT\
+├── \logs\ # Logs are saved here
 │   └── August 02, 2021 01-00 pm.log
+├── \plugins\ # Folder for Autorun plugins, same behavior as above autorun and hook.lua, but meant for plugin developers.
+│   └── \Safety\
+│       ├── \src\
+|       |   ├── autorun.lua
+|       |   └── hook.lua
+│       └── plugin.toml
+├── settings.toml # See autorun/src/configs/settings.toml
 └── ...
 ```
 
 ### 🗃️ Fields
-Here are the fields for the ``sautorun`` table that gets passed in scripthook.
-| Field    | Type             | Description                                                             |
-| ---      | ---              | ---                                                                     |
-| NAME     | string           | Name of the script, ex: @lua/this/that.lua                              |
-| CODE     | string           | The contents of the script                                              |
-| CODE_LEN | number           | Length of the script                                                    |
-| IP       | string           | IP of the server you are currently connected to                         |
-| STARTUP  | boolean          | Whether the script is running from ``autorun.lua`` (true) or false      |
-| log      | fn(string, uint?)| A function that logs to your autorun console. Second param is level ascending with urgency, 1 being error, 2 warning, 3, info, 4 debug, 5 trace. Default 3        |
-| require | fn(string) | Works like gmod's include function. Does not cache like regular lua's require for now. Runs a script local to autorun/scripts and passes the returned values |
+You can find what is passed to the scripthook environment in [examples/fields.lua](examples/fields.lua) as an EmmyLua definitions file.  
+This could be used with something like a vscode lua language server extension for intellisense 👍
 
 ### ✍️ Examples
 __hook.lua__  
 This file runs before every single lua script run on your client from addons and servers.
+You can ``return true`` to not run the script, or a string to replace it.
 ```lua
-local script = sautorun.CODE
+-- Replace all 'while true do end' scripts with 'while false do end' 😎
+local script = Autorun.CODE
 if script:find("while true do end") then
-	sautorun.log("Found an evil script!")
-	-- Run our modified script that will replace all ``while true do end`` with ``while false do end``. 😎
-
+	Autorun.log("Found an evil script!")
 	return string.Replace(script, "while true do end", "while false do end")
-
-	-- OR: return true to not run the script at all.
 end
 ```
-__autorun.lua__  
-This will be the first lua script to run on your client when you join a server, use this to make detours and whatnot.
-```lua
-local ERROR, WARN, INFO, DEBUG, TRACE = 1, 2, 3, 4, 5
-sautorun.log( "Connected to server " .. sautorun.IP, DEBUG )
-```
+
+You can find more [here](examples)
 
 ## ⬇️ Downloading
-### Stable
+### 🦺 Stable
 You can get a 'stable' release from [the releases](https://github.com/Vurv78/Autorun-rs/releases/latest).
-### Bleeding Edge
+### 🩸 Bleeding Edge
 You can get the absolute latest download (from code in the repo) in [the Github Actions tab](https://github.com/Vurv78/Autorun-rs/actions/workflows/downloads.yml)  
-Note it may not work as expected.
+Note it may not work as expected (but I'd advise to try this out before trying to report an issue to see if it has been fixed)
+
+__If you are using this as a menu plugin 🧩, make sure the DLL is named ``gmsv_autorun_win<arch>.dll``__
 
 ## 🛠️ Building
 You may want to build this yourself if you want to make changes / contribute (or don't trust github actions for whatever reason..)

autorun/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "autorun"
-version = "1.0.0-beta6"
+version = "1.0.0"
 authors = ["Vurv78 <Vurv78@users.noreply.github.com>"]
 edition = "2021"
 publish = false

autorun/src/configs/mod.rs

@@ -6,16 +6,100 @@ macro_rules! adir {
 	};
 }
 
-pub static DUMP_DIR: &str = concat!(adir!(), "/lua_dumps");
+pub const DUMP_DIR: &str = concat!(adir!(), "/lua_dumps");
 #[cfg(feature = "logging")]
-pub static LOG_DIR: &str = concat!(adir!(), "/logs");
-pub static INCLUDE_DIR: &str = concat!(adir!(), "/scripts");
-pub static PLUGIN_DIR: &str = concat!(adir!(), "/plugins");
+pub const LOG_DIR: &str = concat!(adir!(), "/logs");
+pub const INCLUDE_DIR: &str = concat!(adir!(), "/scripts");
+pub const PLUGIN_DIR: &str = concat!(adir!(), "/plugins");
 
-pub static AUTORUN_PATH: &str = concat!(adir!(), "/autorun.lua");
-pub static HOOK_PATH: &str = concat!(adir!(), "/hook.lua");
+pub const AUTORUN_PATH: &str = concat!(adir!(), "/autorun.lua");
+pub const HOOK_PATH: &str = concat!(adir!(), "/hook.lua");
+pub const SETTINGS_PATH: &str = concat!(adir!(), "/settings.toml");
 
 pub fn path(path: &str) -> std::path::PathBuf {
 	let home = home::home_dir().expect("Couldn't get your home directory!");
 	home.join(path)
 }
+
+// I know I could just derive / impl Default for all of these settings,
+// but then there wouldn't be comments to explain what each setting is for.
+use serde::{Deserialize, Serialize};
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Settings {
+	pub autorun: AutorunSettings,
+	pub filesteal: FileSettings,
+	pub logging: LoggerSettings,
+	pub plugins: PluginSettings
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct AutorunSettings {
+	pub hide: bool
+}
+#[derive(Debug, Deserialize, Serialize)]
+pub struct FileSettings {
+	pub enabled: bool,
+	pub format: String
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct LoggerSettings {
+	pub enabled: bool,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct PluginSettings {
+	pub enabled: bool
+}
+
+use crate::logging::{error, info};
+
+use once_cell::sync::Lazy;
+pub static SETTINGS: Lazy<Settings> = Lazy::new(|| {
+	let settings_file = path(SETTINGS_PATH);
+	let default_settings = include_str!("settings.toml");
+
+	if settings_file.exists() {
+		match std::fs::read_to_string(&settings_file) {
+			Ok(content) => {
+				match toml::from_str(&content) {
+					Ok(settings) => settings,
+					Err(why) => {
+						error!("Failed to parse your autorun/settings.toml file: {why}");
+
+						toml::from_str(default_settings)
+							.expect("Failed to parse default settings")
+					}
+				}
+			},
+			Err(why) => {
+				error!("Failed to read your settings file '{why}'. Using default settings!");
+
+				toml::from_str(default_settings)
+					.expect("Failed to parse default settings")
+			}
+		}
+	} else {
+		// No settings file, create file with default settings, and use that.
+		match std::fs::File::create(settings_file) {
+			Err(why) => {
+				error!("Couldn't create settings file: {why}");
+			},
+			Ok(mut handle) => {
+				use std::io::Write;
+				match handle.write_all( default_settings.as_bytes() ) {
+					Err(why) => {
+						error!("Couldn't write default settings: {why}");
+					},
+					Ok(_) => {
+						info!("No settings found, created default settings file!");
+					}
+				}
+			}
+		};
+
+		toml::from_str(default_settings)
+			.expect("Failed to parse default settings")
+	}
+
+});

autorun/src/configs/settings.toml

@@ -0,0 +1,22 @@
+[autorun]
+# Whether to hide on startup
+hide = false
+
+[plugins]
+# Whether to run saved plugins
+enabled = true
+
+[logging]
+# Whether to disable saving log files to disk in autorun/logs
+# Will still print info/errors to your console
+enabled = true
+
+[filesteal]
+# Whether to save lua files from detours in autorun/lua_dumps
+enabled = true
+
+# Format to use when saving folders
+# Valid tags:
+# <ip> IP Address of the server (with port)
+# <hostname> Hostname of the server (Currently will just return CLIENT, so don't use.)
+format = "<ip>"

autorun/src/global.rs

@@ -1,5 +1,4 @@
 /// Most of this should be reworked later.
-use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 
 use once_cell::sync::Lazy;
@@ -9,7 +8,4 @@ use autorun_shared::Realm;
 type LuaScript = Vec<(Realm, String)>;
 // Scripts waiting to be ran in painttraverse
 pub static LUA_SCRIPTS: Lazy<Arc<Mutex<LuaScript>>> =
-	Lazy::new(|| Arc::new(Mutex::new(Vec::new())));
-
-pub static LOGGING_ENABLED: AtomicBool = AtomicBool::new(true);
-pub static FILESTEAL_ENABLED: AtomicBool = AtomicBool::new(true);
+	Lazy::new(|| Arc::new(Mutex::new(Vec::new())));