resolve some todos in az-core

azalea-block/src/range.rs

@@ -44,3 +44,19 @@ impl Add for BlockStates {
         }
     }
 }
+
+impl From<HashSet<azalea_registry::Block>> for BlockStates {
+    fn from(set: HashSet<azalea_registry::Block>) -> Self {
+        Self {
+            set: set.into_iter().map(|b| b.into()).collect(),
+        }
+    }
+}
+
+impl From<&HashSet<azalea_registry::Block>> for BlockStates {
+    fn from(set: &HashSet<azalea_registry::Block>) -> Self {
+        Self {
+            set: set.iter().map(|&b| b.into()).collect(),
+        }
+    }
+}

azalea-core/Cargo.toml

@@ -13,10 +13,9 @@ bevy_ecs = { workspace = true, optional = true }
 nohash-hasher = { workspace = true }
 num-traits = { workspace = true }
 serde = { workspace = true, optional = true }
-#serde_json = { workspace = true }
 simdnbt = { workspace = true }
 tracing = { workspace = true }
-#uuid = { workspace = true }
+azalea-chat = { path = "../azalea-chat", version = "0.11.0" }
 
 [features]
 bevy_ecs = ["dep:bevy_ecs"]

azalea-core/src/direction.rs

@@ -62,7 +62,10 @@ impl Direction {
     }
 }
 
-// TODO: make azalea_block use this instead of FacingCardinal
+/// The four cardinal directions.
+///
+/// Note that azalea_block has a similar enum named `FacingCardinal` that is
+/// used for block states.
 #[derive(Clone, Copy, Debug, AzBuf, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub enum CardinalDirection {

azalea-core/src/game_type.rs

@@ -1,6 +1,7 @@
 use std::io::{Cursor, Write};
 
 use azalea_buf::{AzaleaRead, AzaleaReadVar, AzaleaWrite, BufReadError};
+use azalea_chat::translatable_component::TranslatableComponent;
 use tracing::debug;
 
 /// A Minecraft gamemode, like survival or creative.
@@ -51,26 +52,15 @@ impl GameMode {
         )
     }
 
-    pub fn short_name(&self) -> &'static str {
-        // TODO: these should be translated
-        // TranslatableComponent("selectWorld.gameMode." + string2)
-        match self {
-            GameMode::Survival => "Survival",
-            GameMode::Creative => "Creative",
-            GameMode::Adventure => "Adventure",
-            GameMode::Spectator => "Spectator",
-        }
+    /// The short translatable display name for the gamemode, like "Survival".
+    pub fn short_name(&self) -> TranslatableComponent {
+        TranslatableComponent::new(format!("selectWorld.gameMode.{}", self.name()), vec![])
     }
 
-    pub fn long_name(&self) -> &'static str {
-        // TODO: These should be translated TranslatableComponent("gameMode." +
-        // string2);
-        match self {
-            GameMode::Survival => "Survival Mode",
-            GameMode::Creative => "Creative Mode",
-            GameMode::Adventure => "Adventure Mode",
-            GameMode::Spectator => "Spectator Mode",
-        }
+    /// The long translatable display name for the gamemode, like "Survival
+    /// Mode".
+    pub fn long_name(&self) -> TranslatableComponent {
+        TranslatableComponent::new(format!("gameMode.{}", self.name()), vec![])
     }
 
     pub fn from_name(name: &str) -> GameMode {
@@ -82,6 +72,16 @@ impl GameMode {
             _ => panic!("Unknown game type name: {name}"),
         }
     }
+
+    /// The internal name for the game mode, like "survival".
+    pub fn name(&self) -> &'static str {
+        match self {
+            GameMode::Survival => "survival",
+            GameMode::Creative => "creative",
+            GameMode::Adventure => "adventure",
+            GameMode::Spectator => "spectator",
+        }
+    }
 }
 
 impl GameMode {

azalea-core/src/math.rs

@@ -1,4 +1,8 @@
-use std::{f64::consts::PI, sync::LazyLock};
+use std::{
+    f64::consts::PI,
+    ops::{Add, Div, Sub},
+    sync::LazyLock,
+};
 
 pub const EPSILON: f64 = 1.0E-7;
 
@@ -24,17 +28,22 @@ pub fn cos(x: f32) -> f32 {
     SIN[x]
 }
 
-// TODO: make this generic
-pub fn binary_search(mut min: i32, max: i32, predicate: &dyn Fn(i32) -> bool) -> i32 {
+pub fn binary_search<
+    T: Ord + PartialOrd + Add<Output = T> + Sub<Output = T> + Div<Output = T> + From<u8> + Copy,
+>(
+    mut min: T,
+    max: T,
+    predicate: impl Fn(T) -> bool,
+) -> T {
     let mut diff = max - min;
-    while diff > 0 {
-        let diff_mid = diff / 2;
+    while diff > T::from(0) {
+        let diff_mid = diff / T::from(2);
         let mid = min + diff_mid;
         if predicate(mid) {
             diff = diff_mid;
         } else {
-            min = mid + 1;
-            diff -= diff_mid + 1;
+            min = mid + T::from(1);
+            diff = diff - (diff_mid + T::from(1));
         }
     }