stash changes

Author: andrewgazelka

Cargo.lock

@@ -103,7 +103,9 @@ rkyv = '0.8.8'
 serde = '1.0.217'
 serde_json = '1.0.140'
 slotmap = '1.0.7'
-bevy = { git = "https://github.com/bevyengine/bevy"}
+#bevy = { git = "https://github.com/bevyengine/bevy"}
+bevy = "0.16.0"
+eyre = { version = "0.6.12" }
 snafu = '0.8.5'
 syn = '2.0.99'
 tango-bench = "0.6.0"

Cargo.toml

@@ -2,7 +2,6 @@ use std::{collections::HashMap, io::Write};
 
 use derive_build::Build;
 use bevy::prelude::*;
-use flecs_ecs::macros::Component;
 use slotmap::{SecondaryMap, SlotMap, new_key_type};
 use valence_protocol::{Encode, ItemKind, ItemStack, Packet};
 

crates/hyperion-crafting/src/lib.rs

@@ -1,16 +1,18 @@
 [dependencies]
-anyhow = {workspace = true}
-directories = {workspace = true}
-sha2 = {workspace = true}
-hex = {workspace = true}
-hyperion-packet-macros = {workspace = true}
-tracing = {workspace = true}
-reqwest = {workspace = true}
-flate2 = {workspace = true}
-tar = {workspace = true}
-tokio-util = {workspace = true}
-tokio = {workspace = true}
-futures-util = {workspace = true}
+bevy = { workspace = true }
+bytemuck = { workspace = true }
+directories = { workspace = true }
+eyre = { workspace = true }
+flate2 = { workspace = true }
+futures-util = { workspace = true }
+hex = { workspace = true }
+hyperion-packet-macros = { workspace = true }
+reqwest = { workspace = true }
+sha2 = { workspace = true }
+tar = { workspace = true }
+tokio = { workspace = true }
+tokio-util = { workspace = true }
+tracing = { workspace = true }
 valence_protocol = { workspace = true }
 
 [lints]

crates/hyperion-utils/Cargo.toml

@@ -1,8 +1,8 @@
 use std::path::PathBuf;
 
-use anyhow::Context;
+use bevy::prelude::*;
 use directories::ProjectDirs;
-use flecs_ecs::core::{World, WorldGet};
+use eyre::WrapErr;
 use futures_util::stream::StreamExt;
 use sha2::Digest;
 use tar::Archive;
@@ -14,16 +14,8 @@ use crate::AppId;
 pub fn cached_save<U: reqwest::IntoUrl + 'static>(
     world: &World,
     url: U,
-) -> impl Future<Output = anyhow::Result<PathBuf>> + 'static {
-    let project_dirs = world
-        .get::<&AppId>(
-            |AppId {
-                 qualifier,
-                 organization,
-                 application,
-             }| { ProjectDirs::from(qualifier, organization, application) },
-        )
-        .expect("failed to get AppId");
+) -> impl Future<Output = eyre::Result<PathBuf>> + 'static {
+    let project_dirs = world.resource::<AppId>();
 
     let cache = project_dirs.cache_dir();
 
@@ -43,7 +35,7 @@ pub fn cached_save<U: reqwest::IntoUrl + 'static>(
             // download
             let response = reqwest::get(url)
                 .await
-                .with_context(|| format!("failed to get {url_str}"))?;
+                .wrap_err_with(|| format!("failed to get {url_str}"))?;
 
             let byte_stream = response.bytes_stream();
             // Convert the byte stream into an AsyncRead
@@ -65,7 +57,7 @@ pub fn cached_save<U: reqwest::IntoUrl + 'static>(
                     .unpack(&directory)
                     .context("failed to unpack archive")?;
 
-                anyhow::Ok(())
+                eyre::Ok(())
             });
 
             handle.await??;

crates/hyperion-utils/src/cached_save.rs

@@ -1,72 +1,53 @@
-use flecs_ecs::{
-    core::World,
-    macros::Component,
-    prelude::{Entity, Module},
-};
-
 mod cached_save;
 mod lifetime;
+use std::path::PathBuf;
+
+use bevy::prelude::*;
 pub use cached_save::cached_save;
+use eyre::WrapErr;
 pub use lifetime::*;
 
-pub trait EntityExt {
-    fn minecraft_id(&self) -> i32;
-
-    fn from_minecraft_id(id: i32) -> Self;
+pub trait EntityExt: Sized {
+    fn minecraft_id(&self) -> eyre::Result<i32>;
+    fn from_minecraft_id(id: i32) -> eyre::Result<Self>;
 }
 
+// todo(bevy): this is probably different with bevy
+
+// we need a mapping from Bevy entity id to Minecraft entity id
+// some
 impl EntityExt for Entity {
-    fn minecraft_id(&self) -> i32 {
-        let raw = self.0;
-        // Convert entity id into two u32s
-        let most_significant = (raw >> 32) as u32;
-
-        #[expect(
-            clippy::cast_possible_truncation,
-            reason = "we are getting the least significant bits, we expect truncation"
-        )]
-        let least_significant = raw as u32;
-
-        // Ensure most_significant >> 4 does not overlap with least_significant
-        // and that least_significant AND most_significant is 0
-        // this is the "thread" space which allows for 2^6 = 64 threads
-        debug_assert_eq!(
-            most_significant >> 6,
-            0,
-            "Entity ID is too large for Minecraft"
-        );
-
-        debug_assert!(
-            least_significant < (1 << 26),
-            "Entity ID is too large for Minecraft (must fit in 2^26)"
-        );
-
-        // Combine them into a single i32
-        let result = (most_significant << 26) | least_significant;
-
-        #[expect(
-            clippy::cast_possible_wrap,
-            reason = "we do not care about sign changes, we expect wrap"
-        )]
-        let result = result as i32;
-
-        result
+    fn minecraft_id(&self) -> eyre::Result<i32> {
+        let index = self.index();
+        let generation = self.generation();
+
+        let index_u16 = u16::try_from(index)
+            .wrap_err("entity index is too large to create a Minecraft entity id.")?;
+
+        let generation_u16 = u16::try_from(generation)
+            .wrap_err("entity generation is too large to create a Minecraft entity id.")?;
+
+        let index_u32 = u32::from(index_u16);
+        let generation_u32 = u32::from(generation_u16);
+
+        let raw_u32 = index_u32 << 16 | generation_u32;
+
+        Ok(bytemuck::cast(raw_u32))
     }
 
-    fn from_minecraft_id(id: i32) -> Self {
-        #[expect(clippy::cast_sign_loss, reason = "we do not care about sign changes.")]
-        let id = id as u32;
+    fn from_minecraft_id(id: i32) -> eyre::Result<Self> {
+        let id: u32 = bytemuck::cast(id);
 
-        let least_significant = id & ((1 << 26) - 1);
-        let most_significant = (id >> 26) & 0x3F;
+        let index = id >> 16;
+        let generation = id & 0xFFFF;
 
-        let raw = (u64::from(most_significant) << 32) | u64::from(least_significant);
-        Self(raw)
+        let raw_u64 = u64::from(index) | (u64::from(generation) << 32);
+        Ok(Self::from_bits(raw_u64))
     }
 }
 
 /// Represents application identification information used for caching and other system-level operations
-#[derive(Component)]
+#[derive(Resource)]
 pub struct AppId {
     /// The qualifier/category of the application (e.g. "com", "org", "hyperion")
     pub qualifier: String,
@@ -76,17 +57,44 @@ pub struct AppId {
     pub application: String,
 }
 
+impl AppId {
+    #[must_use]
+    pub fn cache_dir(&self) -> PathBuf {
+        let project_dirs = directories::ProjectDirs::from(
+            self.qualifier.as_str(),
+            self.organization.as_str(),
+            self.application.as_str(),
+        )
+        .unwrap();
+        project_dirs.cache_dir().to_path_buf()
+    }
+}
+
 #[derive(Component)]
 pub struct HyperionUtilsModule;
 
-impl Module for HyperionUtilsModule {
-    fn module(world: &World) {
-        world.component::<AppId>();
-
-        world.set(AppId {
+impl Plugin for HyperionUtilsModule {
+    fn build(&self, app: &mut App) {
+        app.insert_resource(AppId {
             qualifier: "github".to_string(),
             organization: "hyperion-mc".to_string(),
             application: "generic".to_string(),
         });
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_entity_id() {
+        let entity = Entity::from_raw(0xDEAD_BEEF);
+        let id = entity.minecraft_id().unwrap();
+        assert_eq!(id, 0xDEAD_BEEF);
+
+        let entity = Entity::from_raw(0xDEAD_BEEF);
+        let id = entity.minecraft_id().unwrap();
+        assert_eq!(id, 0xDEAD_BEEF);
+    }
+}

crates/hyperion-utils/src/lib.rs

@@ -2,8 +2,7 @@
 
 use std::{fmt::Debug, fs::File, io::Read, path::Path};
 
-use bevy::log::Resource;
-use flecs_ecs::macros::Component;
+use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 use tracing::{info, instrument, warn};
 

crates/hyperion/src/common/config.rs

@@ -4,7 +4,7 @@ use std::{
     time::Duration,
 };
 
-use flecs_ecs::macros::Component;
+use bevy::prelude::*;
 use libdeflater::CompressionLvl;
 use valence_protocol::CompressionThreshold;
 

crates/hyperion/src/common/mod.rs

@@ -1,9 +1,8 @@
 //! See [`AsyncRuntime`].
 
 use std::sync::Arc;
-use bevy::log::Resource;
+use bevy::prelude::*;
 use derive_more::{Deref, DerefMut};
-use flecs_ecs::{core::World, macros::Component};
 use kanal::{Receiver, Sender};
 
 /// Type alias for world callback functions

crates/hyperion/src/common/runtime.rs

@@ -1,7 +1,4 @@
 pub mod mojang;
 
-mod sendable;
-mod tracing_ext;
-
 pub use sendable::*;
 pub use tracing_ext::*;

crates/hyperion/src/common/util/mod.rs

@@ -2,8 +2,8 @@
 
 use std::{sync::Arc, time::Duration};
 
-use anyhow::{Context, bail};
-use flecs_ecs::macros::Component;
+use eyre::{Context, bail};
+use bevy::prelude::*;
 use serde_json::Value;
 use tokio::{
     sync::Semaphore,
@@ -101,7 +101,7 @@ impl MojangClient {
     }
 
     /// Gets a player's UUID from their username.
-    pub async fn get_uuid(&self, username: &str) -> anyhow::Result<Uuid> {
+    pub async fn get_uuid(&self, username: &str) -> eyre::Result<Uuid> {
         let url = self.provider.username_url(username);
         let json_object = self.response_raw(&url).await?;
 
@@ -115,7 +115,7 @@ impl MojangClient {
     }
 
     /// Gets a player's username from their UUID.
-    pub async fn get_username(&self, uuid: Uuid) -> anyhow::Result<String> {
+    pub async fn get_username(&self, uuid: Uuid) -> eyre::Result<String> {
         let url = self.provider.uuid_url(&uuid);
         let json_object = self.response_raw(&url).await?;
 
@@ -128,18 +128,18 @@ impl MojangClient {
     }
 
     /// Gets player data from their UUID.
-    pub async fn data_from_uuid(&self, uuid: &Uuid) -> anyhow::Result<Value> {
+    pub async fn data_from_uuid(&self, uuid: &Uuid) -> eyre::Result<Value> {
         let url = self.provider.uuid_url(uuid);
         self.response_raw(&url).await
     }
 
     /// Gets player data from their username.
-    pub async fn data_from_username(&self, username: &str) -> anyhow::Result<Value> {
+    pub async fn data_from_username(&self, username: &str) -> eyre::Result<Value> {
         let url = self.provider.username_url(username);
         self.response_raw(&url).await
     }
 
-    async fn response_raw(&self, url: &str) -> anyhow::Result<Value> {
+    async fn response_raw(&self, url: &str) -> eyre::Result<Value> {
         self.rate_limit
             .acquire()
             .await