prepared for 0.5.0 release;

removed debug message from filesystem;

Author: PSteinhaus

CHANGELOG.md

@@ -1,3 +1,22 @@
+# 0.5.0
+
+## Added
+
+* added `filesystem::load_file_async` to allow for file loading on WASM as well
+
+## Changed
+
+* updated `miniquad` to 0.3.0-alpha.38 (highest version currently compatible with the docker build script and without
+an icon bug on windows)
+* changed `offset` behavior and added default error type to `EventHandler` to match `ggez` 0.7.0
+* made `filesystem::open` check the cache first and then only load files whenever they're not present in the cache
+* `filesystem::open` now internally uses `miniquad::fs::load_file`, allowing to load files on Android now as well
+  * ```cargo
+    [package.metadata.android]
+    assets = "<your ressource folder>/"
+    ```
+    can be used in your `Cargo.toml` file to specify which folder to include in the apk as the assets folder
+
 # 0.4.2
 
 * added a dependency on `twox_hash 1.5.0` to coerce semver into using a `rand < 0.8` in order to avoid `getrandom`, so

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "good-web-game"
-version = "0.4.2"
+version = "0.5.0"
 authors = ["not-fl3 <[email protected]>", "PSteinhaus"]
 license = "MIT"
 edition = "2021"
@@ -26,7 +26,7 @@ mint = "0.5"
 cgmath = { version = "0.17", features = ["mint"] }
 twox-hash = "=1.5.0"    # necessary to force a version of rand < 0.8 to avoid getrandom
 glyph_brush = "0.7"
-miniquad = "0.3.0-alpha.45"
+miniquad = "=0.3.0-alpha.38"
 image = { version = "0.22", default-features = false, features = ["png_codec"] }
 serde = "1"
 serde_derive = "1"

README.md

@@ -9,10 +9,10 @@
 
 good-web-game is a wasm32-unknown-unknown implementation of a [ggez](https://github.com/ggez/ggez) subset on top of [miniquad](https://github.com/not-fl3/miniquad/). Originally built to run [Zemeroth](https://github.com/ozkriff/zemeroth) on the web.
 
-It has been recently updated to support much of the ggez 0.6.1 API. If you're already working with ggez you might use this library to port your game to the web (or even mobile).
+It currently supports most of the ggez 0.7.0 API. If you're already working with ggez you might use this library to port your game to the web (or even mobile).
 Since it also runs well on desktop it also offers an alternative implementation of ggez, which might always come in handy.
 
-If you are just looking for a well supported minimal high-level engine on top of miniquad you might want to take a look at [macroquad](https://github.com/not-fl3/macroquad/).
+If you are just looking for a well supported, more serious, minimal high-level engine on top of miniquad you might want to take a look at [macroquad](https://github.com/not-fl3/macroquad/).
 
 ## Supported Platforms
 
@@ -22,22 +22,23 @@ The idea behind good-web-game is to offer a way to easily port ggez games to the
     <img width="90%" src="about/supported_platforms.svg">
 </p>
 
-Note that we don't give any guarantees for iOS / macOS support, as we currently simply don't have Macs lying around to test it on. It _should_ work just fine though.
+Note that we don't give any guarantees for iOS / macOS support, as we currently simply don't have Macs lying around to test it on. In theory, it _should_ work though.
 
 ## Status
 
-"good-web-game" implements most of the ggez 0.6.1 API.
+"good-web-game" implements most of the ggez 0.7.0 API.
 
 ### Differences
 
 * boilerplate code differs slightly, [as shown here](https://github.com/PSteinhaus/PSteinhaus.github.io/tree/main/ggez/web-examples#ggez-animation-example)
-* audio API differs slightly due to use of `quad-snd` instead of `rodio` for easy portability
+* audio API differs somewhat due to use of `quad-snd` instead of `rodio` for easy portability
 * if you want to run on the web, shaders have to be written in GLSL100, due to support for WebGL1
 * API for creation of shaders and their corresponding uniform structs differs slightly, but the workflow remains the same, see [the `shader` example](examples/shader.rs)
 
 ### Missing / Not available:
 
-* ggez (and therefore good-web-game) loads files in a blocking fashion, which doesn't work on Wasm (and is also currently not supported on mobile)
+* ggez (and therefore good-web-game) usually loads files in a blocking fashion, which doesn't work on WASM
+  * loading files asynchronously is possible through [`load_file_async`](https://docs.rs/good-web-game/0.5.0/good_web_game/filesystem/fn.load_file_async.html) everywhere though
 * filesystem with writing access (if you need it take a look at [`quad-storage`](https://github.com/optozorax/quad-storage))
 * writing your own event loop (doesn't make much sense on callback-only platforms like HTML5)
 * spatial audio (overall audio support is still relatively limited)
@@ -59,13 +60,13 @@ You can also check out [astroblasto running on the web](https://psteinhaus.githu
 
 To build and run an example as a native binary:
 
-```rust
+```
 cargo run --example astroblasto
 ```
 
 ### WebAssembly
 
-```rust
+```
 rustup target add wasm32-unknown-unknown
 cargo build --example astroblasto --target wasm32-unknown-unknown
 ```

examples/astroblasto.rs

@@ -16,7 +16,6 @@ use ggez::timer;
 use ggez::{audio, graphics};
 use ggez::{Context, GameResult};
 use std::f32::consts::PI;
-use std::{env, path};
 
 type Point2 = glam::Vec2;
 type Vector2 = glam::Vec2;

src/error.rs

@@ -89,7 +89,7 @@ impl From<lyon::lyon_tessellation::geometry_builder::GeometryBuilderError> for G
 
 impl From<zip::result::ZipError> for GameError {
     fn from(e: zip::result::ZipError) -> GameError {
-        let errstr = format!("Zip error: {}", e.to_string());
+        let errstr = format!("Zip error: {}", e);
         GameError::ResourceLoadError(errstr)
     }
 }

src/filesystem.rs

@@ -26,6 +26,7 @@ pub struct Filesystem {
 }
 
 impl Filesystem {
+    #[allow(clippy::redundant_closure)]
     pub(crate) fn new(conf: &Conf) -> Filesystem {
         let mut files = HashMap::new();
 
@@ -129,8 +130,6 @@ impl Filesystem {
             path
         };
 
-        println!("loading with path {}", &path);
-
         let buf = load_file_inner(&path)?;
         let bytes = io::Cursor::new(buf);
         Ok(File { bytes })

src/graphics/text.rs

@@ -131,25 +131,14 @@ where
 
 /// Cached font metrics that we can keep attached to a `Text`
 /// so we don't have to keep recalculating them.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 struct CachedMetrics {
     string: Option<String>,
     width: Option<f32>,
     height: Option<f32>,
     glyph_positions: Vec<mint::Point2<f32>>,
 }
 
-impl Default for CachedMetrics {
-    fn default() -> CachedMetrics {
-        CachedMetrics {
-            string: None,
-            width: None,
-            height: None,
-            glyph_positions: Vec::new(),
-        }
-    }
-}
-
 /// Drawable text object.  Essentially a list of [`TextFragment`](struct.TextFragment.html)'s
 /// and some cached size information.
 ///