├── .gitignore
├── Cargo.toml
├── LICENSE
├── README.md
├── example
    ├── Cargo.toml
    ├── core
    │   ├── Cargo.toml
    │   └── src
    │   │   └── main.rs
    └── game_mod
    │   ├── Cargo.toml
    │   └── src
    │       └── lib.rs
└── src
    └── lib.rs


/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | /target/
3 | 
4 | Cargo.lock
5 | /example/Cargo.lock
6 | /example/target
7 | 
8 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "bevy-modding"
 3 | version = "0.1.0"
 4 | authors = ["Arkadiusz Zylkowski <arkadiuszzylkowski@gmail.com"]
 5 | edition = "2018"
 6 | 
 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 8 | 
 9 | [dependencies]
10 | live-reload = "0.2.0"
11 | bevy = "0.5.0"
12 | walkdir = "2.3.2"


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Arkadiusz Żyłkowski
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # bevy-modding
 2 | Simple plugin enabling you to make your game moddable in Bevy engine. Basically it loads native library and calls `init()` function. Modders have complete access to bevy's `AppBuilder` and can add systems, plugins, assets etc. Currently works only on linux.
 3 | 
 4 | ## Usage
 5 | You have to bear in mind that all mods supplied for your game NEED to be compiled with the same version of compiler as game and to the same target platform as the game.
 6 | 
 7 | In the `main.rs` file add `ModdingPlugin` with the bevy `AppBulder`, remember to specify mods folder path.
 8 | Create separate crate for your mod and add
 9 | ```toml
10 | [lib]
11 | crate-type = ["cdylib"]
12 | 
13 | [dependencies]
14 | live-reload = "0.2.0"
15 | bevy = "0.5.0"
16 | bevy-modding = { version = "0.1.0", path = "path"}
17 | ```
18 | To the `Cargo.toml` file of the mod. Then in order for your mod to be properly mod loaded you need to use macro that let's for communication between mod and main game. You do that like this:
19 | ```rust
20 | #[macro_use]            // Let's you use macro from other crate
21 | 
22 | use bevy::prelude::*;
23 | use bevy_modding::*;
24 | 
25 | #[repr(C)]
26 | struct State;           // State struct, it's needed by crate that loads your mod
27 | 
28 | mod_loader!{
29 |     host: Host;         
30 |     state: State;
31 |     init: init;         // Passing initialize function for your mod
32 | }
33 | ```
34 | Your init function can look like this:
35 | ```rust
36 | fn hello_from_mod(){
37 |     println!("Hello from mod!");
38 | }
39 | 
40 | fn init(host: &mut Host, _state: &mut State) {
41 |     host.app_builder
42 |         .add_system(hello_from_mod.system());
43 | }
44 | ```
45 | Now if you compile both your mod and core of the game you have to move compiled `.so` file from mod and place it in your designated mods folder and run the core game. 
46 | 
47 | ## Safety
48 | For now this crate is just proof of concept and probably root of something bigger. For now loaded mods don't have any restrictions to what they can do, eg. they can read files from your computer, download files from malicious websites etc. That's something I will be targeting in future updates. I am relatively new to Rust and I don't really know any crates for sandboxing, will have to research that in order to make this plugin safe.
49 | 
50 | ## Todo
51 | - [X] Have Fun
52 | - [x] Create simple working example
53 | - [ ] Add Windows compatibility
54 | - [ ] Make documentation
55 | 


--------------------------------------------------------------------------------
/example/Cargo.toml:
--------------------------------------------------------------------------------
1 | [workspace]
2 | members = [
3 |     "core",
4 |     "game_mod",
5 | ]
6 | 


--------------------------------------------------------------------------------
/example/core/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "core"
 3 | version = "0.1.0"
 4 | authors = ["Arkadiusz Zylkowski <arkadiuszzylkowski@gmail.com>"]
 5 | edition = "2018"
 6 | 
 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 8 | 
 9 | [dependencies]
10 | bevy = "0.5.0"
11 | bevy-modding = { version = "0.1.0", path = "../../../bevy-modding"}


--------------------------------------------------------------------------------
/example/core/src/main.rs:
--------------------------------------------------------------------------------
1 | use bevy::prelude::*;
2 | use bevy_modding::*;
3 | 
4 | fn main() {
5 |     App::build()
6 |         .add_plugin(ModdingPlugin::new( "target/debug/mods"))
7 |         .run();
8 | }
9 | 


--------------------------------------------------------------------------------
/example/game_mod/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "game_mod"
 3 | version = "0.1.0"
 4 | authors = ["Arkadiusz Zylkowski <arkadiuszzylkowski@gmail.com>"]
 5 | edition = "2018"
 6 | 
 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 8 | 
 9 | [lib]
10 | crate-type = ["cdylib"]
11 | 
12 | [dependencies]
13 | live-reload = "0.2.0"
14 | bevy = "0.5.0"
15 | bevy-modding = { version = "0.1.0", path = "../../../bevy-modding"}


--------------------------------------------------------------------------------
/example/game_mod/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #[macro_use]            // Let's you use macro from other crate
 2 | 
 3 | use bevy::prelude::*;
 4 | use bevy_modding::*;
 5 | 
 6 | #[repr(C)]
 7 | struct State;           // State struct, it's needed by crate that loads your mod
 8 | 
 9 | mod_loader!{
10 |     host: Host;
11 |     state: State;
12 |     init: init;         // Passing initialize function for your mod
13 | }
14 | 
15 | fn hello_from_mod(){
16 |     println!("Hello from mod!");
17 | }
18 | 
19 | fn init(host: &mut Host, _state: &mut State) {
20 |     host.app_builder
21 |         .add_system(hello_from_mod.system());
22 | }


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | extern crate live_reload;
 2 | 
 3 | use bevy::prelude::*;
 4 | use walkdir::WalkDir;
 5 | 
 6 | /// Live reload api for communication between mod and main game
 7 | pub struct Host<'a> {
 8 |     pub app_builder: &'a mut AppBuilder,
 9 | }
10 | 
11 | type ModLoader<'a> = live_reload::Reloadable<Host<'a>>;
12 | pub struct ModdingPlugin<'a> {
13 |     mod_folder_path: &'a str,
14 | }
15 | 
16 | impl<'a> ModdingPlugin<'a> {
17 |     pub fn new(mod_folder_path: &'a str) -> Self {
18 |         ModdingPlugin { mod_folder_path }
19 |     }
20 | }
21 | 
22 | impl Plugin for ModdingPlugin<'static> {
23 |     fn build(&self, app: &mut AppBuilder) {
24 |         for entry in WalkDir::new(self.mod_folder_path)
25 |             .follow_links(true)
26 |             .into_iter()
27 |             .filter_map(|e| e.ok())
28 |         {
29 |             let f_name = entry.file_name().to_string_lossy();
30 |             if f_name.ends_with(".so"){
31 |                 let host_api = Host { app_builder: app };
32 |                 ModLoader::new(entry.path(),host_api).expect("Cannot load the mod!");
33 |             }
34 |         }
35 |     }
36 | }
37 | 
38 | #[macro_export]
39 | macro_rules! mod_loader {
40 |     (host: $Host:ty;
41 |      state: $State:ty;
42 |      init: $init:ident;) => {
43 |         fn cast<'a>(raw_state: *mut ()) -> &'a mut $State {
44 |             unsafe { &mut *(raw_state as *mut $State) }
45 |         }
46 | 
47 |         fn init_wrapper(host: &mut $Host, raw_state: *mut ()) {
48 |             $init(host, cast(raw_state))
49 |         }
50 | 
51 |         fn reload_wrapper(host: &mut $Host, raw_state: *mut ()) {}
52 | 
53 |         fn update_wrapper(host: &mut $Host, raw_state: *mut ()) -> ::live_reload::ShouldQuit {
54 |             live_reload::ShouldQuit::No
55 |         }
56 | 
57 |         fn unload_wrapper(host: &mut $Host, raw_state: *mut ()) {}
58 | 
59 |         fn deinit_wrapper(host: &mut $Host, raw_state: *mut ()) {}
60 | 
61 |         #[no_mangle]
62 |         pub static RELOAD_API: ::live_reload::internals::ReloadApi<$Host> =
63 |             ::live_reload::internals::ReloadApi {
64 |                 size: ::std::mem::size_of::<$State>,
65 |                 init: init_wrapper,
66 |                 reload: reload_wrapper,
67 |                 update: update_wrapper,
68 |                 unload: unload_wrapper,
69 |                 deinit: deinit_wrapper,
70 |             };
71 |     };
72 | }
73 | 


--------------------------------------------------------------------------------