Update to bevy 0.10

.gitattributes

@@ -2,3 +2,4 @@
 *.png filter=lfs diff=lfs merge=lfs -text
 *.wav filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text

.gitlab-ci.yml

@@ -22,7 +22,7 @@ build-windows:
       - .cargo/bin/
       - target/
   script:
-    - cargo build --release -p ${BINARY_FOLDER} --target x86_64-pc-windows-gnu
+    - cargo build --release --features "embed" -p ${BINARY_FOLDER} --target x86_64-pc-windows-gnu
   artifacts:
     expire_in: 1 day
     paths:
@@ -44,7 +44,7 @@ build-linux:
       - .cargo/bin/
       - target/
   script:
-    - cargo build --release -p ${BINARY_FOLDER} --target x86_64-unknown-linux-gnu
+    - cargo build --release --features "embed" -p ${BINARY_FOLDER} --target x86_64-unknown-linux-gnu
   artifacts:
     expire_in: 1 day
     paths:
@@ -95,7 +95,7 @@ build-web:
     - mkdir "${CI_PROJECT_DIR}/${BINARY_FOLDER}/dist"
     - make assets
     - sed -i 's#public_url = "/"#public_url = "./"#' "${CI_PROJECT_DIR}/${BINARY_FOLDER}/Trunk.toml"
-    - cd "${CI_PROJECT_DIR}/${BINARY_FOLDER}" && trunk build --release
+    - cd "${CI_PROJECT_DIR}/${BINARY_FOLDER}" && trunk build --features "embed" --release
     - cd "${CI_PROJECT_DIR}"
   artifacts:
     expire_in: 1 day
@@ -113,8 +113,8 @@ package-all:
     - cp target/x86_64-unknown-linux-gnu/release/${BINARY_NAME} "dist/${BINARY_NAME}"
     - cp target/x86_64-pc-windows-gnu/release/${BINARY_NAME}.exe "dist/${BINARY_NAME}.exe"
 #    - cp target/aarch64-unknown-linux-gnu/release/${BINARY_NAME} "dist/${BINARY_NAME}.arm64"
-    - cd "${CI_PROJECT_DIR}/dist" && zip -r "windows.zip" "./${BINARY_NAME}.exe" ./assets
-    - cd "${CI_PROJECT_DIR}/dist" && zip -r "linux.x86.zip" "./${BINARY_NAME}" ./assets
+    - cd "${CI_PROJECT_DIR}/dist" && zip -r "windows.zip" "./${BINARY_NAME}.exe" # ./assets
+    - cd "${CI_PROJECT_DIR}/dist" && zip -r "linux.x86.zip" "./${BINARY_NAME}" # ./assets
 #    - cd "${CI_PROJECT_DIR}/dist" && zip -r "linux.arm64.zip" "./${BINARY_NAME}.arm64" ./assets
     - cd "${CI_PROJECT_DIR}/${BINARY_FOLDER}/dist" && zip -r "web.zip" ./*
     - cd "${CI_PROJECT_DIR}" && mv "${CI_PROJECT_DIR}/game_core/dist/web.zip" "${CI_PROJECT_DIR}/dist/web.zip"

Cargo.toml

@@ -16,23 +16,27 @@ log = "0.4.17"
 thiserror = "1.0.37"
 serde = "1.0.147"
 serde_json = "1.0.87"
-iyes_loopless = "0.9.1"
+num-traits = "0.2.15"
 
-micro_musicbox = { version = "0.5.0", features = ["mp3"] }
-micro_banimate = "0.2.1"
-micro_bevy_web_utils = "0.1.0"
+micro_musicbox = { version = "0.6.2", features = ["ogg"] }
+micro_banimate = "0.5.0-beta.2"
+micro_bevy_web_utils = "0.2.0"
+
+bevy_embedded_assets = "0.7.0"
+bevy_tweening = "0.7.0"
 
 [workspace.dependencies.bevy]
-version = "0.9.1"
+version = "0.10.1"
 default-features = false
 features = [
     "bevy_asset",
-    "render",
+    "bevy_sprite",
     "bevy_winit",
     "png",
     "hdr",
     "x11",
     "wayland",
     "serialize",
-    "filesystem_watcher"
+    "filesystem_watcher",
+    "bevy_core_pipeline",
 ]

Makefile

@@ -20,19 +20,25 @@ setup-wayland: linux-deps wayland-deps cargo-deps
 assets:
 	@echo "Beep Boop, No assets needed to be built"
 
+
 run:
 	RUSTFLAGS="-Awarnings" \
-	cargo run -p game_core
+	cargo run --release --features "bevy/dynamic_linking" -p game_core
+
+dirty-build:
+	RUSTFLAGS="-Awarnings" \
+	cargo build --release --features "embed" -p game_core
 
 run-web:
+	RUSTFLAGS="-Awarnings" \
 	cd game_core && trunk serve
 
 check:
-	cargo check --release --features "bevy/dynamic" -p game_core
+	cargo check --release -p game_core
 
 build-windows: clean_dist top_tail
 	docker run --rm --name "${PROJECT_NAME}-build-windows" -v "$(CURRENT_DIRECTORY):/app" -w /app --user $(shell id -u):$(shell id -g) r.lcr.gr/microhacks/bevy-builder \
-		cargo build --release -p game_core --target x86_64-pc-windows-gnu
+		cargo build --release --features "embed" -p game_core --target x86_64-pc-windows-gnu
 	mkdir -p dist
 	cp -r assets dist/assets
 	cp target/x86_64-pc-windows-gnu/release/game_core.exe "dist/${PROJECT_NAME}.exe"
@@ -40,14 +46,14 @@ build-windows: clean_dist top_tail
 
 build-linux: clean_dist top_tail
 	docker run --rm --name "${PROJECT_NAME}-build-linux" -v "$(CURRENT_DIRECTORY):/app" -w /app --user $(shell id -u):$(shell id -g) r.lcr.gr/microhacks/bevy-builder \
-		cargo build --release -p game_core --target x86_64-unknown-linux-gnu
+		cargo build --release --features "embed" -p game_core --target x86_64-unknown-linux-gnu
 	mkdir -p dist
 	cp -r assets dist/assets
 	cp target/x86_64-unknown-linux-gnu/release/game_core "dist/${PROJECT_NAME}"
 	cd dist && zip -r "${PROJECT_NAME}-linux.zip" "./${PROJECT_NAME}" ./assets
 
 build-web: top_tail
-	cd game_core && trunk build --release
+	cd game_core && trunk build --features "embed" --release
 	cd game_core/dist && zip -r "${PROJECT_NAME}-web.zip" ./*
 
 clean_dist:

game_core/Cargo.toml

@@ -5,8 +5,15 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+
+default = []
+embed = []
+
 [dependencies]
 bevy.workspace = true
+bevy_tweening.workspace = true
+bevy_embedded_assets.workspace = true
 
 fastrand.workspace = true
 anyhow.workspace = true
@@ -14,7 +21,7 @@ log.workspace = true
 thiserror.workspace = true
 serde.workspace = true
 serde_json.workspace = true
-iyes_loopless.workspace = true
+num-traits.workspace = true
 
 micro_banimate.workspace = true
 micro_musicbox.workspace = true

game_core/src/assets/loader.rs

@@ -4,6 +4,7 @@ use bevy::asset::LoadState;
 use bevy::ecs::system::SystemParam;
 use bevy::prelude::*;
 use bevy::reflect::TypeUuid;
+use micro_banimate::definitions::AnimationSet;
 use micro_musicbox::prelude::AudioSource;
 
 use crate::assets::{AssetHandles, FixedAssetNameMapping, SpriteSheetConfig};
@@ -55,6 +56,7 @@ impl<'w, 's> AssetTypeLoader<'w, 's> {
 	load_basic_type!(load_images, Image => images);
 	load_basic_type!(load_audio, AudioSource => sounds);
 	load_basic_type!(load_font, Font => fonts);
+	load_basic_type!(load_animation, AnimationSet => animations);
 
 	pub fn load_spritesheet(
 		&mut self,

game_core/src/assets/mod.rs

@@ -2,13 +2,11 @@ mod loader;
 mod resources;
 mod startup;
 
-use bevy::app::{App, Plugin};
-use iyes_loopless::condition::ConditionSet;
-use iyes_loopless::prelude::AppLooplessStateExt;
+use bevy::prelude::*;
 pub use loader::AssetTypeLoader;
 pub use resources::{AssetHandles, AssetNameMapping, FixedAssetNameMapping, SpriteSheetConfig};
 
-use crate::system::flow::AppState;
+use crate::system::flow::{AppScheduleExt, AppState};
 
 pub struct AssetsPlugin;
 impl Plugin for AssetsPlugin {
@@ -16,11 +14,6 @@ impl Plugin for AssetsPlugin {
 		app.init_resource::<AssetHandles>()
 			.add_enter_system(AppState::Preload, startup::start_preload_resources)
 			.add_enter_system(AppState::Preload, startup::start_load_resources)
-			.add_system_set(
-				ConditionSet::new()
-					.run_in_state(AppState::Setup)
-					.with_system(startup::check_load_resources)
-					.into(),
-			);
+			.add_system(startup::check_load_resources.in_set(OnUpdate(AppState::Setup)));
 	}
 }

game_core/src/assets/resources.rs

 use bevy::prelude::*;
 use bevy::utils::HashMap;
+use micro_banimate::definitions::AnimationSet;
 use micro_musicbox::prelude::AudioSource;
 use micro_musicbox::utilities::{SuppliesAudio, TrackType};
 
@@ -37,6 +38,7 @@ pub struct AssetHandles {
 	pub atlas: HashMap<String, Handle<TextureAtlas>>,
 	pub sounds: HashMap<String, Handle<AudioSource>>,
 	pub fonts: HashMap<String, Handle<Font>>,
+	pub animations: HashMap<String, Handle<AnimationSet>>
 }
 
 macro_rules! fetch_wrapper {
@@ -66,6 +68,7 @@ impl AssetHandles {
 	fetch_wrapper!(atlas, TextureAtlas => atlas);
 	fetch_wrapper!(sound, AudioSource => sounds);
 	fetch_wrapper!(font, Font => fonts);
+	fetch_wrapper!(animation, AnimationSet => animations);
 }
 
 impl SuppliesAudio for AssetHandles {

game_core/src/assets/startup.rs

 use bevy::asset::LoadState;
 use bevy::prelude::*;
-use iyes_loopless::prelude::NextState;
 
 use crate::assets::AssetTypeLoader;
 use crate::system::flow::AppState;
 
-pub fn start_preload_resources(mut commands: Commands) {
+pub fn start_preload_resources(
+	mut _commands: Commands,
+	mut next_state: ResMut<NextState<AppState>>,
+) {
 	// TODO: Add preload commands here
-
-	commands.insert_resource(NextState(AppState::Setup))
+	next_state.set(AppState::Setup);
 }
 
 pub fn start_load_resources(mut loader: AssetTypeLoader) {
 	loader.load_images(&[("splash.png", "splash")]);
-	loader.load_audio(&[("splash_sting.mp3", "splash_sting")]);
+	loader.load_audio(&[("splash_sting.ogg", "splash_sting")]);
 }
 
-pub fn check_load_resources(mut commands: Commands, loader: AssetTypeLoader) {
+pub fn check_load_resources(
+	mut commands: Commands,
+	loader: AssetTypeLoader,
+	mut next_state: ResMut<NextState<AppState>>,
+) {
 	let load_states = loader.get_all_load_state();
 	if load_states.iter().all(|state| *state == LoadState::Loaded) {
 		log::info!("Assets loaded successfully");
-		commands.insert_resource(NextState(AppState::Splash))
+		next_state.set(AppState::Splash);
 	}
 }

game_core/src/main.rs

 use bevy::prelude::*;
 use game_core::assets::AssetHandles;
 use game_core::system::flow::AppState;
-use game_core::system::resources::InitAppPlugins;
-use iyes_loopless::prelude::AppLooplessStateExt;
-use micro_musicbox::CombinedAudioPlugins;
-// use remote_events::RemoteEventPlugin;
 
 fn main() {
 	App::new()
-		.add_loopless_state(AppState::Preload)
-		.add_plugins(InitAppPlugins)
+		.add_state::<AppState>()
+		.add_plugins(game_core::system::resources::InitAppPlugins)
 		.add_plugin(game_core::assets::AssetsPlugin)
-		.add_plugins(CombinedAudioPlugins::<AssetHandles>::new())
+		.add_plugins(micro_musicbox::CombinedAudioPlugins::<AssetHandles>::new())
+		.add_plugins(micro_banimate::BanimatePluginGroup)
 		.add_plugin(game_core::splash_screen::SplashScreenPlugin)
 		.add_plugin(game_core::system::camera::CameraManagementPlugin)
-		// .add_plugin(RemoteEventPlugin::<
-		// 	game_core::multiplayer::OutgoingEvent,
-		// 	game_core::multiplayer::IncomingEvent,
-		// >::new())
 		.run();
 }

game_core/src/splash_screen/mod.rs

 use bevy::prelude::*;
-use iyes_loopless::prelude::{AppLooplessStateExt, ConditionSet};
 
-use crate::system::flow::AppState;
+use crate::system::flow::{AppScheduleExt, AppState};
 
 mod components;
 mod systems;
@@ -10,12 +9,7 @@ pub struct SplashScreenPlugin;
 impl Plugin for SplashScreenPlugin {
 	fn build(&self, app: &mut App) {
 		app.add_enter_system(AppState::Splash, systems::setup_splash_screen)
-			.add_system_set(
-				ConditionSet::new()
-					.run_in_state(AppState::Splash)
-					.with_system(systems::tick_splash_system)
-					.into(),
-			)
+			.add_system(systems::tick_splash_system.in_set(OnUpdate(AppState::Splash)))
 			.add_exit_system(AppState::Splash, systems::remove_splash_entities);
 	}
 }

game_core/src/splash_screen/systems.rs

 use bevy::prelude::*;
 use bevy::render::texture::ImageSampler;
-use iyes_loopless::state::NextState;
 use micro_musicbox::music_box::MusicBox;
 
 use crate::assets::AssetHandles;
@@ -33,6 +32,7 @@ pub fn setup_splash_screen(
 	mut image_assets: ResMut<Assets<Image>>,
 	handles: Res<AssetHandles>,
 	mut music_box: MusicBox<AssetHandles>,
+	mut next_state: ResMut<NextState<AppState>>,
 ) {
 	let (window_width, window_height) = virtual_size();
 
@@ -40,7 +40,7 @@ pub fn setup_splash_screen(
 		Some(handle) => handle,
 		None => {
 			log::error!("No splash image was found; Skipping");
-			commands.insert_resource(NextState(AppState::Menu));
+			next_state.set(AppState::Menu);
 			return;
 		}
 	};
@@ -48,7 +48,7 @@ pub fn setup_splash_screen(
 		.get_mut(handle)
 		.expect("An image was stored without the handle being persisted");
 
-	commands.insert_resource(ClearColor(Color::hex("001122").unwrap()));
+	commands.insert_resource(bevy::prelude::ClearColor(Color::hex("001122").unwrap()));
 
 	let scale_factor = match window_width > window_height {
 		true => window_height / image_data.texture_descriptor.size.height as f32,
@@ -92,8 +92,8 @@ pub fn setup_splash_screen(
 }
 
 pub fn tick_splash_system(
-	mut commands: Commands,
 	time: Res<Time>,
+	mut next_state: ResMut<NextState<AppState>>,
 	mut query: Query<(&mut Sprite, &mut SplashAnimation, &mut SplashAnimationTimer)>,
 ) {
 	let tick = time.delta_seconds();
@@ -115,7 +115,7 @@ pub fn tick_splash_system(
 					*anims = *anim.clone();
 				}
 				None => {
-					commands.insert_resource(NextState(AppState::Menu));
+					next_state.set(AppState::Menu);
 				}
 			}
 		}

game_core/src/system/camera.rs

 use bevy::app::App;
+use bevy::core_pipeline::clear_color::ClearColorConfig;
 use bevy::math::{Vec2, Vec3Swizzles};
-use bevy::prelude::{
-	Camera2dBundle, Commands, Component, CoreStage, Entity, OrthographicProjection, Plugin, Query,
-	Transform, With,
-};
+use bevy::prelude::*;
 use bevy::render::camera::ScalingMode;
-use iyes_loopless::prelude::AppLooplessStateExt;
+use bevy::render::view::RenderLayers;
 
-use crate::system::flow::AppState;
+use crate::system::flow::{AppScheduleExt, AppState};
 use crate::system::load_config::virtual_size;
 
 /// A flag component to indicate which entity should be followed by the camera
-#[derive(Component)]
+#[derive(Component, Default)]
 pub struct ChaseCam;
 /// A flag component to indicate a camera that should be used for rendering world entities and sprites
-#[derive(Component)]
+#[derive(Component, Default)]
 pub struct GameCamera;
 
 /// System that creates a default orthographic camera, with correct tags for querying
 pub fn spawn_orthographic_camera(mut commands: Commands) {
+	spawn_camera(
+		&mut commands,
+		(GameCamera,),
+		0,
+		ClearColorConfig::Default,
+	);
+}
+
+pub fn spawn_camera(
+	commands: &mut Commands,
+	tags: impl Bundle,
+	order: isize,
+	clear_color: ClearColorConfig,
+) -> Entity {
 	let (target_width, target_height) = virtual_size();
-	commands.spawn((
-		Camera2dBundle {
-			projection: OrthographicProjection {
-				left: -(target_width / 2.0),
-				right: (target_width / 2.0),
-				top: (target_height / 2.0),
-				bottom: -(target_height / 2.0),
-				scaling_mode: ScalingMode::Auto {
-					min_width: target_width,
-					min_height: target_height,
+
+	commands
+		.spawn((
+			Camera2dBundle {
+				camera: Camera {
+					order,
+					..Default::default()
+				},
+				projection: OrthographicProjection {
+					area: Rect::new(
+						-(target_width / 2.0),
+						-(target_height / 2.0),
+						(target_width / 2.0),
+						(target_height / 2.0),
+					),
+					scaling_mode: ScalingMode::AutoMin {
+						min_width: target_width,
+						min_height: target_height,
+					},
+					..Default::default()
 				},
+				camera_2d: Camera2d { clear_color },
 				..Default::default()
 			},
-			..Default::default()
-		},
-		GameCamera,
-	));
+			RenderLayers::layer(order.max(0).min(RenderLayers::TOTAL_LAYERS as isize - 1) as u8),
+			tags,
+		))
+		.id()
 }
 
 /// System that takes the average location of all chase camera entities, and updates the location
@@ -75,6 +98,6 @@ pub struct CameraManagementPlugin;
 impl Plugin for CameraManagementPlugin {
 	fn build(&self, app: &mut App) {
 		app.add_enter_system(AppState::Preload, spawn_orthographic_camera)
-			.add_system_to_stage(CoreStage::PreUpdate, sync_chase_camera_location);
+			.add_system(sync_chase_camera_location);
 	}
 }

game_core/src/system/flow.rs

-use bevy::prelude::StageLabel;
+use bevy::app::{App, CoreSet, Plugin};
+use bevy::prelude::*;
 
 /// An enum representing the current set of systems that should be running.
 /// Changing states should be done by inserting an `iyes_loopless` `NextState`
 /// resource with the value of one of these app states
-#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash, StageLabel)]
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash, States, Default)]
 pub enum AppState {
 	/// During the preload state, embedded resources will be registered with Bevy.
 	/// Embedded resources will be attached to the asset system with the path
 	/// `internal:{resource-name}`
+	#[default]
 	Preload,
 	/// During the setup state, external resources will be registered by reading from
 	/// the filesystem or the network. Progress can be displayed using the embedded
@@ -22,3 +24,103 @@ pub enum AppState {
 	/// will be spent here.
 	InGame,
 }
+
+pub fn run_in_game(state: Res<State<AppState>>) -> bool {
+	state.0 == AppState::InGame
+}
+pub fn run_in_menu(state: Res<State<AppState>>) -> bool {
+	state.0 == AppState::Menu
+}
+pub fn run_in_splash(state: Res<State<AppState>>) -> bool {
+	state.0 == AppState::Splash
+}
+pub fn run_in_setup(state: Res<State<AppState>>) -> bool {
+	state.0 == AppState::Setup
+}
+
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash, SystemSet)]
+#[system_set(base)]
+pub enum FlowSet {
+	// Any custom processing steps, such as "player actions", or "process AI"
+	Cleanup,
+}
+
+#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Debug, Hash, SystemSet)]
+#[system_set(base)]
+pub enum FlushFlowCommands {
+	// Create an associated flush step where actions will be applied, for each FlowSet
+	FlushCleanup,
+}
+
+pub struct FlowSetPlugin;
+impl Plugin for FlowSetPlugin {
+	fn build(&self, app: &mut App) {
+		app.configure_sets(
+			(
+				CoreSet::UpdateFlush,
+				FlowSet::Cleanup,
+				FlushFlowCommands::FlushCleanup,
+				CoreSet::PostUpdate,
+			)
+				.chain(),
+		)
+		.add_system(apply_system_buffers.in_base_set(FlushFlowCommands::FlushCleanup));
+	}
+}
+
+pub trait AppScheduleExt {
+	fn add_enter_system<M>(
+		&mut self,
+		state: impl States,
+		system: impl IntoSystemAppConfig<M>,
+	) -> &mut Self;
+	fn add_enter_systems<M>(
+		&mut self,
+		state: impl States,
+		system: impl IntoSystemAppConfigs<M>,
+	) -> &mut Self;
+	fn add_exit_system<M>(
+		&mut self,
+		state: impl States,
+		system: impl IntoSystemAppConfig<M>,
+	) -> &mut Self;
+	fn add_exit_systems<M>(
+		&mut self,
+		state: impl States,
+		system: impl IntoSystemAppConfigs<M>,
+	) -> &mut Self;
+}
+
+impl AppScheduleExt for App {
+	fn add_enter_system<M>(
+		&mut self,
+		state: impl States,
+		system: impl IntoSystemAppConfig<M>,
+	) -> &mut Self {
+		self.add_system(system.in_schedule(OnEnter(state)))
+	}
+
+	fn add_enter_systems<M>(
+		&mut self,
+		state: impl States,
+		systems: impl IntoSystemAppConfigs<M>,
+	) -> &mut Self {
+		self.add_systems(systems.in_schedule(OnEnter(state)))
+	}
+
+	fn add_exit_system<M>(
+		&mut self,
+		state: impl States,
+		system: impl IntoSystemAppConfig<M>,
+	) -> &mut Self {
+		self.add_system(system.in_schedule(OnExit(state)))
+	}
+
+	fn add_exit_systems<M>(
+		&mut self,
+		state: impl States,
+		systems: impl IntoSystemAppConfigs<M>,
+	) -> &mut Self {
+		self.add_systems(systems.in_schedule(OnExit(state)))
+	}
+}

game_core/src/system/keycode.rs

+use bevy::prelude::KeyCode;
+
+pub fn keycode_string(code: KeyCode) -> &'static str {
+	match code {
+		KeyCode::Key1 => "Key1",
+		KeyCode::Key2 => "Key2",
+		KeyCode::Key3 => "Key3",
+		KeyCode::Key4 => "Key4",
+		KeyCode::Key5 => "Key5",
+		KeyCode::Key6 => "Key6",
+		KeyCode::Key7 => "Key7",
+		KeyCode::Key8 => "Key8",
+		KeyCode::Key9 => "Key9",
+		KeyCode::Key0 => "Key0",
+		KeyCode::A => "A",
+		KeyCode::B => "B",
+		KeyCode::C => "C",
+		KeyCode::D => "D",
+		KeyCode::E => "E",
+		KeyCode::F => "F",
+		KeyCode::G => "G",
+		KeyCode::H => "H",
+		KeyCode::I => "I",
+		KeyCode::J => "J",
+		KeyCode::K => "K",
+		KeyCode::L => "L",
+		KeyCode::M => "M",
+		KeyCode::N => "N",
+		KeyCode::O => "O",
+		KeyCode::P => "P",
+		KeyCode::Q => "Q",
+		KeyCode::R => "R",
+		KeyCode::S => "S",
+		KeyCode::T => "T",
+		KeyCode::U => "U",
+		KeyCode::V => "V",
+		KeyCode::W => "W",
+		KeyCode::X => "X",
+		KeyCode::Y => "Y",
+		KeyCode::Z => "Z",
+		KeyCode::Escape => "Escape",
+		KeyCode::F1 => "F1",
+		KeyCode::F2 => "F2",
+		KeyCode::F3 => "F3",
+		KeyCode::F4 => "F4",
+		KeyCode::F5 => "F5",
+		KeyCode::F6 => "F6",
+		KeyCode::F7 => "F7",
+		KeyCode::F8 => "F8",
+		KeyCode::F9 => "F9",
+		KeyCode::F10 => "F10",
+		KeyCode::F11 => "F11",
+		KeyCode::F12 => "F12",
+		KeyCode::F13 => "F13",
+		KeyCode::F14 => "F14",
+		KeyCode::F15 => "F15",
+		KeyCode::F16 => "F16",
+		KeyCode::F17 => "F17",
+		KeyCode::F18 => "F18",
+		KeyCode::F19 => "F19",
+		KeyCode::F20 => "F20",
+		KeyCode::F21 => "F21",
+		KeyCode::F22 => "F22",
+		KeyCode::F23 => "F23",
+		KeyCode::F24 => "F24",
+		KeyCode::Snapshot => "Snapshot",
+		KeyCode::Scroll => "Scroll",
+		KeyCode::Pause => "Pause",
+		KeyCode::Insert => "Insert",
+		KeyCode::Home => "Home",
+		KeyCode::Delete => "Delete",
+		KeyCode::End => "End",
+		KeyCode::PageDown => "PageDown",
+		KeyCode::PageUp => "PageUp",
+		KeyCode::Left => "Left",
+		KeyCode::Up => "Up",
+		KeyCode::Right => "Right",
+		KeyCode::Down => "Down",
+		KeyCode::Back => "Back",
+		KeyCode::Return => "Return",
+		KeyCode::Space => "Space",
+		KeyCode::Compose => "Compose",
+		KeyCode::Caret => "Caret",
+		KeyCode::Numlock => "Numlock",
+		KeyCode::Numpad0 => "Numpad0",
+		KeyCode::Numpad1 => "Numpad1",
+		KeyCode::Numpad2 => "Numpad2",
+		KeyCode::Numpad3 => "Numpad3",
+		KeyCode::Numpad4 => "Numpad4",
+		KeyCode::Numpad5 => "Numpad5",
+		KeyCode::Numpad6 => "Numpad6",
+		KeyCode::Numpad7 => "Numpad7",
+		KeyCode::Numpad8 => "Numpad8",
+		KeyCode::Numpad9 => "Numpad9",
+		KeyCode::AbntC1 => "AbntC1",
+		KeyCode::AbntC2 => "AbntC2",
+		KeyCode::NumpadAdd => "NumpadAdd",
+		KeyCode::Apostrophe => "Apostrophe",
+		KeyCode::Apps => "Apps",
+		KeyCode::Asterisk => "Asterisk",
+		KeyCode::Plus => "Plus",
+		KeyCode::At => "At",
+		KeyCode::Ax => "Ax",
+		KeyCode::Backslash => "Backslash",
+		KeyCode::Calculator => "Calculator",
+		KeyCode::Capital => "Capital",
+		KeyCode::Colon => "Colon",
+		KeyCode::Comma => "Comma",
+		KeyCode::Convert => "Convert",
+		KeyCode::NumpadDecimal => "NumpadDecimal",
+		KeyCode::NumpadDivide => "NumpadDivide",
+		KeyCode::Equals => "Equals",
+		KeyCode::Grave => "Grave",
+		KeyCode::Kana => "Kana",
+		KeyCode::Kanji => "Kanji",
+		KeyCode::LAlt => "LAlt",
+		KeyCode::LBracket => "LBracket",
+		KeyCode::LControl => "LControl",
+		KeyCode::LShift => "LShift",
+		KeyCode::LWin => "LWin",
+		KeyCode::Mail => "Mail",
+		KeyCode::MediaSelect => "MediaSelect",
+		KeyCode::MediaStop => "MediaStop",
+		KeyCode::Minus => "Minus",
+		KeyCode::NumpadMultiply => "NumpadMultiply",
+		KeyCode::Mute => "Mute",
+		KeyCode::MyComputer => "MyComputer",
+		KeyCode::NavigateForward => "NavigateForward",
+		KeyCode::NavigateBackward => "NavigateBackward",
+		KeyCode::NextTrack => "NextTrack",
+		KeyCode::NoConvert => "NoConvert",
+		KeyCode::NumpadComma => "NumpadComma",
+		KeyCode::NumpadEnter => "NumpadEnter",
+		KeyCode::NumpadEquals => "NumpadEquals",
+		KeyCode::Oem102 => "Oem102",
+		KeyCode::Period => "Period",
+		KeyCode::PlayPause => "PlayPause",
+		KeyCode::Power => "Power",
+		KeyCode::PrevTrack => "PrevTrack",
+		KeyCode::RAlt => "RAlt",
+		KeyCode::RBracket => "RBracket",
+		KeyCode::RControl => "RControl",
+		KeyCode::RShift => "RShift",
+		KeyCode::RWin => "RWin",
+		KeyCode::Semicolon => "Semicolon",
+		KeyCode::Slash => "Slash",
+		KeyCode::Sleep => "Sleep",
+		KeyCode::Stop => "Stop",
+		KeyCode::NumpadSubtract => "NumpadSubtract",
+		KeyCode::Sysrq => "Sysrq",
+		KeyCode::Tab => "Tab",
+		KeyCode::Underline => "Underline",
+		KeyCode::Unlabeled => "Unlabeled",
+		KeyCode::VolumeDown => "VolumeDown",
+		KeyCode::VolumeUp => "VolumeUp",
+		KeyCode::Wake => "Wake",
+		KeyCode::WebBack => "WebBack",
+		KeyCode::WebFavorites => "WebFavorites",
+		KeyCode::WebForward => "WebForward",
+		KeyCode::WebHome => "WebHome",
+		KeyCode::WebRefresh => "WebRefresh",
+		KeyCode::WebSearch => "WebSearch",
+		KeyCode::WebStop => "WebStop",
+		KeyCode::Yen => "Yen",
+		KeyCode::Copy => "Copy",
+		KeyCode::Paste => "Paste",
+		KeyCode::Cut => "Cut",
+	}
+}

game_core/src/system/mod.rs

 pub mod camera;
 pub mod flow;
+mod keycode;
 pub mod load_config;
 pub mod resources;
 pub mod utilities;
+pub mod web;
 pub mod window;
-pub mod web;
\ No newline at end of file
+
+pub use keycode::keycode_string;

game_core/src/system/resources.rs

 use bevy::app::PluginGroupBuilder;
 use bevy::log::{Level, LogPlugin};
 use bevy::prelude::*;
-use bevy::window::{PresentMode, WindowMode};
+use bevy::window::{PresentMode, WindowMode, WindowResolution};
+use bevy_embedded_assets::EmbeddedAssetPlugin;
 
 use crate::system::load_config::{get_asset_path_string, initial_size};
 
 pub struct DefaultResourcesPlugin;
 impl Plugin for DefaultResourcesPlugin {
 	fn build(&self, app: &mut App) {
-		app.insert_resource(Msaa { samples: 1 })
+		app.insert_resource(Msaa::Off)
 			.insert_resource(ClearColor(Color::hex("040720").unwrap()));
 	}
 }
 pub fn configure_default_plugins() -> PluginGroupBuilder {
 	let (width, height) = initial_size();
-	DefaultPlugins
+	let mut plugin_set = DefaultPlugins
 		.set(WindowPlugin {
-			window: WindowDescriptor {
-				width,
-				height,
+			primary_window: Some(Window {
+				resolution: WindowResolution::new(width, height),
 				resizable: true,
 				mode: WindowMode::Windowed,
-				title: String::from("Bevy 2D Template"),
+				title: String::from("Game Core"),
 				present_mode: PresentMode::AutoNoVsync,
 				fit_canvas_to_parent: true,
 				..Default::default()
-			},
+			}),
 			..Default::default()
 		})
 		.set(AssetPlugin {
@@ -35,15 +35,23 @@ pub fn configure_default_plugins() -> PluginGroupBuilder {
 		.set(ImagePlugin::default_nearest())
 		.set(LogPlugin {
 			filter: String::from(
-				"info,symphonia_core=warn,symphonia_bundle_mp3=warn,wgpu_core=warn,wgpu_hal=warn",
+				"info,game_core=debug,symphonia_core=warn,symphonia_format_ogg=warn,winit=warn,symphonia_bundle_mp3=warn,wgpu_core=warn,wgpu_hal=warn",
 			),
 			level: Level::DEBUG,
-		})
+		});
+
+	if cfg!(feature = "embed") {
+		plugin_set.add_before::<AssetPlugin, _>(EmbeddedAssetPlugin)
+	} else {
+		plugin_set
+	}
 }
 
 pub struct InitAppPlugins;
 impl PluginGroup for InitAppPlugins {
 	fn build(self) -> PluginGroupBuilder {
-		configure_default_plugins().add(DefaultResourcesPlugin).add(super::web::WebPlugin)
+		configure_default_plugins()
+			.add(DefaultResourcesPlugin)
+			.add(super::web::WebPlugin)
 	}
 }

game_core/src/system/utilities.rs

@@ -30,3 +30,25 @@ pub fn f32_min_mag(a: f32, b: f32) -> f32 {
 		b.abs()
 	}
 }
+
+#[macro_export]
+macro_rules! deref_as {
+	($name: ident => $target: ty) => {
+		impl std::ops::Deref for $name {
+			type Target = $target;
+			fn deref(&self) -> &Self::Target {
+				&self.0
+			}
+		}
+		impl std::ops::DerefMut for $name {
+			fn deref_mut(&mut self) -> &mut Self::Target {
+				&mut self.0
+			}
+		}
+		impl From<$target> for $name {
+			fn from(other: $target) -> $name {
+				$name(other)
+			}
+		}
+	};
+}