Merge pull request #12 from fallible-algebra/version-bump/bevy-0.17

Update to 0.17.0

Author: foxzool

Cargo.toml

@@ -14,12 +14,12 @@ keywords = ["bevy", "http", "plugin", "wasm"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy_app = "0.16"
-bevy_derive = "0.16"
+bevy_app = "0.17.0-rc.1"
+bevy_derive = "0.17.0-rc.1"
 #bevy_hierarchy = "0.16.0"
-bevy_ecs = { version = "0.16", features = ["multi_threaded"] }
-bevy_tasks = "0.16"
-bevy_log = "0.16"
+bevy_ecs = { version = "0.17.0-rc.1", features = ["multi_threaded"] }
+bevy_tasks = "0.17.0-rc.1"
+bevy_log = "0.17.0-rc.1"
 
 crossbeam-channel = "0.5.11"
 ehttp = { version = "0.5.0", features = ["native-async", "json"] }
@@ -29,7 +29,7 @@ serde_json = "1.0"
 
 
 [dev-dependencies]
-bevy = { version = "0.16", default-features = false, features = [
+bevy = { version = "0.17.0-rc.1", default-features = false, features = [
     "animation",
     "bevy_asset",
     "bevy_gilrs",
@@ -40,11 +40,13 @@ bevy = { version = "0.16", default-features = false, features = [
     "bevy_gltf",
     "bevy_render",
     "bevy_sprite",
+    "bevy_sprite_render",
     "bevy_text",
     "bevy_ui",
     "bevy_window",
     "bevy_log",
     "multi_threaded",
+    "zstd_rust",
     "png",
     "hdr",
     "x11",

README.md

@@ -32,24 +32,24 @@ fn main() {
     app.run();
 }
 
-fn send_request(mut ev_request: EventWriter<TypedRequest<IpInfo>>) {
+fn send_request(mut ev_request: MessageWriter<TypedRequest<IpInfo>>) {
     if let Ok(request) = HttpClient::new()
         .get("https://api.ipify.org?format=json")
         .try_with_type::<IpInfo>()
     {
-        ev_request.send(request);
+        ev_request.write(request);
     }
 }
 
 /// consume TypedResponse<IpInfo> events
-fn handle_response(mut events: ResMut<Events<TypedResponse<IpInfo>>>) {
+fn handle_response(mut events: ResMut<Messages<TypedResponse<IpInfo>>>) {
     for response in events.drain() {
         let response: IpInfo = response.into_inner();
         println!("ip info: {:?}", response);
     }
 }
 
-fn handle_error(mut ev_error: EventReader<TypedResponseError<IpInfo>>) {
+fn handle_error(mut ev_error: MessageReader<TypedResponseError<IpInfo>>) {
     for error in ev_error.read() {
         println!("Error retrieving IP: {}", error.err);
     }

examples/ipinfo.rs

@@ -13,7 +13,7 @@ fn main() {
         .run();
 }
 
-fn send_request(mut ev_request: EventWriter<HttpRequest>) {
+fn send_request(mut ev_request: MessageWriter<HttpRequest>) {
     match HttpClient::new().get("https://api.ipify.org").try_build() {
         Ok(request) => {
             ev_request.write(request);
@@ -24,13 +24,13 @@ fn send_request(mut ev_request: EventWriter<HttpRequest>) {
     }
 }
 
-fn handle_response(mut ev_resp: EventReader<HttpResponse>) {
+fn handle_response(mut ev_resp: MessageReader<HttpResponse>) {
     for response in ev_resp.read() {
         println!("response: {:?}", response.text());
     }
 }
 
-fn handle_error(mut ev_error: EventReader<HttpResponseError>) {
+fn handle_error(mut ev_error: MessageReader<HttpResponseError>) {
     for error in ev_error.read() {
         println!("Error retrieving IP: {}", error.err);
     }

examples/observer.rs

@@ -28,7 +28,7 @@ fn init_request(mut commands: Commands) {
 
 fn send_request(
     clients: Query<&HttpClient, With<IpRequestMarker>>,
-    mut ev_request: EventWriter<HttpRequest>,
+    mut ev_request: MessageWriter<HttpRequest>,
 ) {
     let requests: Vec<HttpRequest> = clients
         .iter()
@@ -44,10 +44,10 @@ fn send_request(
     ev_request.write_batch(requests);
 }
 
-fn handle_response(response: Trigger<HttpResponse>) {
-    println!("response: {:?}", response.text());
+fn handle_response(response: On<HttpObserved<HttpResponse>>) {
+    println!("response: {:?}", response.event().inner().text());
 }
 
-fn handle_error(error: Trigger<HttpResponseError>) {
-    println!("Error retrieving IP: {}", error.err);
+fn handle_error(error: On<HttpObserved<HttpResponseError>>) {
+    println!("Error retrieving IP: {}", error.event().inner().err);
 }

examples/typed.rs

@@ -19,7 +19,7 @@ fn main() {
     app.run();
 }
 
-fn send_request(mut ev_request: EventWriter<TypedRequest<IpInfo>>) {
+fn send_request(mut ev_request: MessageWriter<TypedRequest<IpInfo>>) {
     match HttpClient::new()
         .get("https://api.ipify.org?format=json")
         .try_with_type::<IpInfo>()
@@ -34,14 +34,14 @@ fn send_request(mut ev_request: EventWriter<TypedRequest<IpInfo>>) {
 }
 
 /// consume TypedResponse<IpInfo> events
-fn handle_response(mut events: ResMut<Events<TypedResponse<IpInfo>>>) {
+fn handle_response(mut events: ResMut<Messages<TypedResponse<IpInfo>>>) {
     for response in events.drain() {
         let response: IpInfo = response.into_inner();
         println!("ip info: {:?}", response);
     }
 }
 
-fn handle_error(mut ev_error: EventReader<TypedResponseError<IpInfo>>) {
+fn handle_error(mut ev_error: MessageReader<TypedResponseError<IpInfo>>) {
     for error in ev_error.read() {
         println!("Error retrieving IP: {}", error.err);
     }

examples/window.rs

@@ -82,7 +82,7 @@ fn setup(mut commands: Commands) {
 }
 
 fn send_request(
-    mut ev_request: EventWriter<HttpRequest>,
+    mut ev_request: MessageWriter<HttpRequest>,
     mut status_query: Query<&mut Text, (With<ResponseText>, Without<ResponseIP>)>,
     mut ip_query: Query<&mut Text, (With<ResponseIP>, Without<ResponseText>)>,
 ) {
@@ -107,7 +107,7 @@ fn send_request(
 }
 
 fn handle_response(
-    mut ev_resp: EventReader<HttpResponse>,
+    mut ev_resp: MessageReader<HttpResponse>,
     mut status_query: Query<&mut Text, (With<ResponseText>, Without<ResponseIP>)>,
     mut ip_query: Query<&mut Text, (With<ResponseIP>, Without<ResponseText>)>,
 ) {
@@ -120,7 +120,7 @@ fn handle_response(
         }
     }
 }
-fn handle_error(mut ev_error: EventReader<HttpResponseError>) {
+fn handle_error(mut ev_error: MessageReader<HttpResponseError>) {
     for error in ev_error.read() {
         println!("Error retrieving IP: {}", error.err);
     }

src/lib.rs

@@ -7,7 +7,7 @@ use bevy_tasks::IoTaskPool;
 use crossbeam_channel::{Receiver, Sender};
 use ehttp::{Headers, Request, Response};
 
-use crate::prelude::TypedRequest;
+use crate::{prelude::TypedRequest, typed::HttpObserved};
 
 pub mod prelude;
 mod typed;
@@ -94,9 +94,9 @@ impl Plugin for HttpClientPlugin {
         if !app.world().contains_resource::<HttpClientSetting>() {
             app.init_resource::<HttpClientSetting>();
         }
-        app.add_event::<HttpRequest>();
-        app.add_event::<HttpResponse>();
-        app.add_event::<HttpResponseError>();
+        app.add_message::<HttpRequest>();
+        app.add_message::<HttpResponse>();
+        app.add_message::<HttpResponseError>();
         app.add_systems(Update, (handle_request, handle_tasks));
     }
 }
@@ -135,7 +135,7 @@ impl HttpClientSetting {
     }
 }
 
-#[derive(Event, Debug, Clone)]
+#[derive(Event, Message, Debug, Clone)]
 pub struct HttpRequest {
     pub from_entity: Option<Entity>,
     pub request: Request,
@@ -208,7 +208,7 @@ impl HttpClient {
     /// use bevy_http_client::HttpClient;
     /// use bevy_ecs::entity::Entity;
     ///
-    /// let entity = Entity::from_raw(42); // Example entity
+    /// let entity = Entity::from_raw_u32(42).unwrap(); // Example entity
     /// let http_client = HttpClient::new_with_entity(entity);
     /// ```
     pub fn new_with_entity(entity: Entity) -> Self {
@@ -588,7 +588,7 @@ impl HttpClient {
     /// use bevy_http_client::HttpClient;
     /// use bevy_ecs::entity::Entity;
     ///
-    /// let entity = Entity::from_raw(42); // Example entity
+    /// let entity = Entity::from_raw_u32(42).unwrap(); // Example entity
     /// let http_client = HttpClient::new().entity(entity);
     /// ```
     pub fn entity(mut self, entity: Entity) -> Self {
@@ -737,7 +737,9 @@ impl HttpClient {
         since = "0.8.3",
         note = "Use `try_with_type()` instead for better error handling"
     )]
-    pub fn with_type<T: for<'a> serde::Deserialize<'a>>(self) -> TypedRequest<T> {
+    pub fn with_type<T: Send + Sync + 'static + for<'a> serde::Deserialize<'a>>(
+        self,
+    ) -> TypedRequest<T> {
         TypedRequest::new(
             Request {
                 method: self.method.expect("method is required"),
@@ -782,7 +784,7 @@ impl HttpClient {
     ///     Err(e) => eprintln!("Build failed: {}", e),
     /// }
     /// ```
-    pub fn try_with_type<T: for<'a> serde::Deserialize<'a>>(
+    pub fn try_with_type<T: Send + Sync + 'static + for<'a> serde::Deserialize<'a>>(
         self,
     ) -> Result<TypedRequest<T>, HttpClientBuilderError> {
         let method = self.method.ok_or(HttpClientBuilderError::MissingMethod)?;
@@ -807,11 +809,11 @@ impl HttpClient {
 }
 
 /// wrap for ehttp response
-#[derive(Event, Debug, Clone, Deref)]
+#[derive(Event, Message, Debug, Clone, Deref)]
 pub struct HttpResponse(pub Response);
 
 /// wrap for ehttp error
-#[derive(Event, Debug, Clone, Deref)]
+#[derive(Event, Message, Debug, Clone, Deref)]
 pub struct HttpResponseError {
     pub err: String,
 }
@@ -832,7 +834,7 @@ pub struct RequestTask {
 fn handle_request(
     mut commands: Commands,
     mut req_res: ResMut<HttpClientSetting>,
-    mut requests: EventReader<HttpRequest>,
+    mut requests: MessageReader<HttpRequest>,
     q_tasks: Query<&RequestTask>,
 ) {
     let thread_pool = IoTaskPool::get();
@@ -856,24 +858,26 @@ fn handle_request(
                         match response {
                             Ok(res) => {
                                 if let Some(mut events) =
-                                    world.get_resource_mut::<Events<HttpResponse>>()
+                                    world.get_resource_mut::<Messages<HttpResponse>>()
                                 {
-                                    events.send(HttpResponse(res.clone()));
+                                    events.write(HttpResponse(res.clone()));
                                 } else {
                                     bevy_log::error!("HttpResponse events resource not found");
                                 }
-                                world.trigger_targets(HttpResponse(res), entity);
+                                world.trigger(HttpObserved::new(entity, HttpResponse(res)));
                             }
                             Err(e) => {
                                 if let Some(mut events) =
-                                    world.get_resource_mut::<Events<HttpResponseError>>()
+                                    world.get_resource_mut::<Messages<HttpResponseError>>()
                                 {
-                                    events.send(HttpResponseError::new(e.to_string()));
+                                    events.write(HttpResponseError::new(e.to_string()));
                                 } else {
                                     bevy_log::error!("HttpResponseError events resource not found");
                                 }
-                                world
-                                    .trigger_targets(HttpResponseError::new(e.to_string()), entity);
+                                world.trigger(HttpObserved::new(
+                                    entity,
+                                    HttpResponseError::new(e.to_string()),
+                                ));
                             }
                         }
 

src/prelude.rs

@@ -1,5 +1,5 @@
 pub use super::{
-    typed::{HttpTypedRequestTrait, TypedRequest, TypedResponse, TypedResponseError},
+    typed::{HttpObserved, HttpTypedRequestTrait, TypedRequest, TypedResponse, TypedResponseError},
     HttpClient, HttpClientBuilderError, HttpClientPlugin, HttpClientSetting, HttpRequest,
     HttpResponse, HttpResponseError, JsonFallback, JsonSerializationError, RequestTask,
 };