awoo

Signed-off-by: Balazs Horvath <[email protected]>

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+levels/biomes.ldtk filter=lfs diff=lfs merge=lfs -text

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: ka-de

.github/workflows/rust.yml

@@ -0,0 +1,48 @@
+name: Rust
+
+on:
+    push:
+        branches: ["master"]
+    pull_request:
+        branches: ["master"]
+
+env:
+    CARGO_TERM_COLOR: always
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: actions/checkout@v4
+            - name: Cargo Cache
+              uses: actions/cache@v4
+              with:
+                  path: |
+                      ~/.cargo/registry
+                      ~/.cargo/git
+                      target
+                  key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml') }}
+                  restore-keys: |
+                      ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.toml') }}
+                      ${{ runner.os }}-cargo
+            - name: Install dependencies
+              run: sudo apt-get install -y clang pkg-config libx11-dev libasound2-dev libudev-dev libxkbcommon-x11-0 libwayland-dev libxkbcommon-dev libxcb-render0-dev libxcb-shape0-dev libxcb-xfixes0-dev mesa-vulkan-drivers
+            - name: Cargo Update
+              run: cargo update --verbose
+            - name: Build Debug
+              run: cargo build --features "bevy/dynamic_linking" --verbose
+            - name: Run tests
+              run: cargo test --features "bevy/dynamic_linking" --all-targets --verbose
+            - name: Pedantic Linting
+              run: cargo clippy -- -W clippy::pedantic
+#            - name: Package Debug Build
+#              run: |
+#                  DATE=$(date +%Y-%m-%d)
+#                  COMMIT_HASH=$(git rev-parse --short "$GITHUB_SHA")
+#                  zip -r "separated-debug-build-${DATE}-${COMMIT_HASH}.zip" target/debug/
+#            - name: Upload Debug Build
+#              uses: actions/upload-artifact@v2
+#              with:
+#                  name: Debug Build
+#                  path: "*.zip"

.gitignore

@@ -0,0 +1,11 @@
+debug/
+target/
+rustc-ice-*.txt
+
+Cargo.lock
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# MSVC Windows builds of rustc generate these, which store debugging information
+*.pdb

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "assets"]
+	path = assets
+	url = https://huggingface.co/REPLACE/assets

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "useTabs": false,
+  "tabWidth": 4,
+  "printWidth": 100,
+  "endOfLine": "lf"
+}

.vscode/launch.json

@@ -0,0 +1,75 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "sourceLanguages": ["rust"],
+            "name": "Debug SEPARATED",
+            "cargo": {
+                "args": ["build", "--bin=separated", "--package=separated"],
+                "filter": {
+                    "name": "separated",
+                    "kind": "bin"
+                }
+            },
+            "env": {
+                "CARGO_MANIFEST_DIR": "${workspaceFolder}",
+                "RUSTFLAGS": "-Clinker=rust-lld.exe -Zshare-generics=n -Zthreads=0",
+                "PATH": "${env:HOME}/.rustup/toolchains/nightly-x86_64-pc-windows-msvc/bin;${workspaceFolder}/target/debug/deps;${env:PATH}"
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}
+
+/*
+ * The `#![allow(clippy::match_same_arms)]` is a Rust attribute that allows a specific lint warning to be ignored.
+ * 
+ * `#!` is a Rust attribute, which is a way to annotate a module or crate with additional information.
+ * `allow` is a specific attribute that allows a lint warning to be ignored.
+ * `clippy::match_same_arms` is the name of the lint warning being allowed.
+ *
+ * The `match_same_arms` lint warns when a match expression has multiple arms with the same pattern. For example:
+ *
+ * ```rust
+match foo {
+    1 => println!("one"),
+    1 => println!("also one"), // warning: same arm
+}
+ * ```
+ * 
+ * In this case, `clippy` would normally warn about the duplicate arm, suggesting that it might be an error.
+ * By adding the `#![allow(clippy::match_same_arms)]` attribute, you're telling `clippy` to ignore this specific
+ * warning for the entire crate or module. This can be useful if you intentionally have a match expression with
+ * duplicate arms, or if you're working on a legacy codebase that hasn't been updated to avoid this pattern.
+ * 
+ * Note that this attribute only affects the `clippy` linter, and not the standard Rust compiler warnings.
+ */
+
+/*
+ * RUSTFLAGS="-Funsafe-code --cap-lints=warn" cargo check
+ *
+ * This command will cause the compilation to fail if unsafe code is detected.
+ * However, it’s important to note that this method might not be foolproof for all cases,
+ * as some dependencies might require unsafe code to function correctly, and this could
+ * lead to false positives or prevent your project from compiling.
+ *
+ * Remember, while unsafe code is often necessary for low-level system programming tasks,
+ * its usage should be minimized and carefully reviewed to maintain the safety guarantees
+ * that Rust provides.
+ */
+
+/*
+ * The `--cap-lints=warn` flag in Rust is used to set the maximum lint level for the entire project to warn.
+ *
+ * This means that even if a lint is defined with a more severe levelsuch as deny or forbid,
+ * it will only issue a warning rather than causing the compilation to fail. Essentially, this flag ensures that
+ * no matter what lint levels are specified within the code or by dependencies, they will not exceed a warning level.
+ *
+ * This can be particularly useful when compiling a large number of crates, some of which you may not have control over,
+ * and you want to ensure that lint issues do not prevent the project from building. However, it’s important to note that
+ * while this flag can help with getting a project to compile, it does not address the underlying issues that the lints are warning about.
+ * It’s generally a good idea to review and address lint warnings to maintain code quality.
+ */

Cargo.toml

@@ -0,0 +1,182 @@
+cargo-features = ["profile-rustflags"]
+
+[package]
+name = "separated"
+version = "1.0.0"
+edition = "2021"
+authors = ["Balazs Horvath", "Gaeros"]
+description = "A 2D platformer game."
+documentation = "https://cringe.live/docs/games/separated/"
+readme = "README.md"
+homepage = "https://cringe.live/separated/"
+repository = "https://github.com/ka-de/separated"
+license = "MIT"
+keywords = ["gamedev"]
+publish = false
+
+[lints.rust]
+unsafe_code = "warn"
+
+[workspace]
+resolver = "2"
+
+[profile.awoo]
+inherits = "dev"
+opt-level = 0
+debug = true
+debug-assertions = true
+overflow-checks = true
+lto = false
+panic = 'unwind'
+incremental = true
+codegen-units = 16
+
+# Enable all compiler optimizations in debug builds.
+[profile.dev]
+opt-level = 3
+
+# Enable all compiler optimizations for dependencies in debug builds.
+# With some link time optimizations, it might produce better optimized
+# code, using whole-program analysis, at the cost of longer linking time.
+[profile.dev.package."*"]
+opt-level = 3
+codegen-units = 1
+
+# Enable every possible compiler optimizations and stripping for release builds.
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+strip = true
+
+[features]
+# Build release with `cargo build --release --no-default-features`
+default = ["dev_features"]
+dev_features = [
+  "bevy/trace",
+  "bevy/file_watcher",
+  "bevy/embedded_watcher",
+  "bevy_progress/debug",
+  "bevy_rapier2d/debug-render-2d",
+  "big-brain/trace",
+  #"sickle_ui/dev",
+  "bevy_progress/debug",
+  # "bevy_incandescent/debug",
+  "dep:bevy-inspector-egui",
+  # Allow egui to take priority over actions when processing inputs.
+  "input-manager/egui",
+  "dep:bevy_mod_debugdump",
+  "dep:graphviz-rust",
+]
+
+[build-dependencies]
+embed-resource = "2.4.2"
+
+[dependencies]
+winit = { version = "0.29.15", default-features = false, features = ["rwh_06"] }
+image = { version = "0.25.1", default-features = false, features = ["png"] }
+rand = "0.8.5"
+unicode-segmentation = "1.11.0"
+bevy_rapier2d = { version = "0.26.0", default-features = false, features = [
+  "dim2",
+  "simd-stable",
+  "parallel",
+] }
+wgpu = { version = "0.19.3", default-features = false, features = [
+  "dx12",
+  "metal",
+  "naga",
+  "naga-ir",
+] }
+bevy_rand = { git = "https://github.com/ka-de/bevy_rand", features = [
+  #"rand_chacha",
+  "wyrand",
+  "serialize",
+] }
+input-manager = { git = "https://github.com/ka-de/input-manager", features = [
+  "timing",
+  "ui",
+] }
+bevy_device_lang = { git = "https://github.com/ka-de/bevy_device_lang" }
+aery = { git = "https://github.com/ka-de/aery" }
+bevy_vector_shapes = { git = "https://github.com/ka-de/bevy_vector_shapes" }
+# pathfinding = { git = "https://github.com/ka-de/pathfinding" }
+big-brain = { git = "https://github.com/ka-de/big-brain" }
+bevy_mod_debugdump = { git = "https://github.com/ka-de/bevy_mod_debugdump", optional = true }
+graphviz-rust = { version = "0.9.0", optional = true }
+seldom_state = { git = "https://github.com/ka-de/seldom_state" }
+# bevy_text_input = { git = "https://github.com/ka-de/bevy_text_input" }
+# bevy_flurx = { git = "https://github.com/ka-de/bevy_flurx" }
+# bevy_magic_light_2d = { git = "https://github.com/ka-de/bevy_magic_light_2d" }
+#bevy_incandescent = { git = "https://github.com/ka-de/bevy_incandescent", features = [
+#  "debug",
+#  "ray_marching",
+#] }
+bevy_mod_aseprite = { git = "https://github.com/ka-de/bevy_mod_aseprite" }
+
+[dependencies.bevy]
+version = "0.13.2"
+default-features = false
+features = [
+  "png",
+  "vorbis",
+  "bevy_audio",
+  "animation",
+  "bevy_gilrs",           # Gamepad support
+  "bevy_sprite",
+  "bevy_animation",
+  "bevy_ui",
+  "bevy_core_pipeline",   # This sounds important, but I've only seen camera stuff in it for 2D?
+  "bevy_text",
+  "subpixel_glyph_atlas",
+  "bevy_render",
+  "multi-threaded",
+  "bevy_winit",
+  "x11",
+  "wayland",
+  # Future Stuff
+  #"bevy_state",           # Needs research
+  #"sysinfo_plugin",       # OwO whats this?
+]
+
+[dependencies.bevy_asset_loader]
+git = "https://github.com/ka-de/bevy_asset_loader"
+default-features = false
+features = ["2d", "standard_dynamic_assets", "progress_tracking"]
+
+[dependencies.bevy_ecs_ldtk]
+git = "https://github.com/ka-de/bevy_ecs_ldtk"
+
+[dependencies.bevy-inspector-egui]
+git = "https://github.com/ka-de/bevy-inspector-egui"
+optional = true
+default-features = false
+features = ["highlight_changes"]
+
+#[dependencies.bevy_tweening]
+#git = "https://github.com/ka-de/bevy_tweening"
+
+[dependencies.bevy_progress]
+git = "https://github.com/ka-de/bevy_progress"
+features = ["assets"]
+default-features = false
+
+[dependencies.bevy-steamworks]
+git = "https://github.com/ka-de/bevy_steamworks"
+features = ["serde"]
+
+[dependencies.sickle_ui]
+git = "https://github.com/ka-de/sickle_ui"
+
+[dependencies.bevy_yarnspinner]
+git = "https://github.com/ka-de/YarnSpinner-Rust"
+
+[dependencies.bevy_hanabi]
+git = "https://github.com/ka-de/bevy_hanabi"
+default-features = false
+features = ["2d"]
+
+[dependencies.rodio]
+version = "0.17"
+default-features = false
+features = ["vorbis"]

LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) Balazs Horvath and Contributors
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,326 @@
+# SEPARATED
+
+---
+
+## Introduction
+
+SEPARATED is a 2D platformer game where you can talk to NPCs. Most of the game is not yet implemented.
+
+## Table of Contents
+
+- [SEPARATED](#separated)
+  - [Introduction](#introduction)
+  - [Table of Contents](#table-of-contents)
+  - [Player Inputs ∆](#player-inputs-)
+  - [Debugging Keyboard Shortcuts](#debugging-keyboard-shortcuts)
+  - [TODO](#todo)
+  - [`filesystem_watcher` and `asset_processor`](#filesystem_watcher-and-asset_processor)
+  - [Rust Things 🦀](#rust-things-)
+    - [Run in Wolf Mode (Debug)](#run-in-wolf-mode-debug)
+    - [Pedantic linting](#pedantic-linting)
+    - [Linting on all packages, treating warnings as errors](#linting-on-all-packages-treating-warnings-as-errors)
+    - [Format code](#format-code)
+    - [Test without default features](#test-without-default-features)
+    - [Test with only the `bevy_ui` features](#test-with-only-the-bevy_ui-features)
+    - [Test with all features enabled](#test-with-all-features-enabled)
+    - [Test with all features enabled on nightly](#test-with-all-features-enabled-on-nightly)
+    - [Generate documentation with all features enabled](#generate-documentation-with-all-features-enabled)
+  - [`seldom_state` + `input_manager` Example](#seldom_state--input_manager-example)
+
+## Player Inputs ∆
+
+| Input        |          KeyCode          |     Gamepad Button/Axis     |
+| :----------- | :-----------------------: | :-------------------------: |
+| **Run**      |         **Shift**         | Xbox: **X** PS5: **Square** |
+| **Interact** |           **E**           |   Xbox: **B** PS5: **◯**    |
+| **Attack1**  |           **Q**           |      Xbox/PS5: **L1**       |
+| **Jump**     |         **Space**         |   Xbox: **A** PS5: **╳**    |
+| **Move**     | **WASD** + **Arrow Keys** |    **Any Axis + D-Pad**     |
+
+## Debugging Keyboard Shortcuts
+
+| Action                         | KeyCode |
+| :----------------------------- | :-----: |
+| Toggle Physics Wireframes      |   F9    |
+| StateInspector (**GameState**) |   F10   |
+| WorldInspector                 |   F11   |
+
+## TODO
+
+---
+
+- **Use WyRand instead of `thread_rng()`**
+
+```rust
+fn print_random_value(mut rng: ResMut<GlobalEntropy<WyRand>>) {
+    println!("Random value: {}", rng.next_u32());
+}
+
+use bevy_rand::WyRand;
+use bevy_rand::prelude::{GlobalEntropy, ForkableRng};
+
+#[derive(Component)]
+struct Source;
+
+fn setup_source(mut commands: Commands, mut global: ResMut<GlobalEntropy<WyRand>>) {
+    commands
+        .spawn((
+            Source,
+            global.fork_rng(),
+        ));
+}
+```
+
+---
+
+```rust
+if ( jumping || falling ) {
+
+    if velocity.y.abs() < jumpHangTimeThreshold {
+        // Increase acceleration for this duration also.
+
+        // Reduce gravity.
+    }
+}
+
+// If the player is moving downwards..
+if velocity.y < 0 {
+    // Increase gravity while falling.
+    gravityScale *= fallGravityMultiplier;
+
+    // Cap maximum fall speed, so when falling over large distances,
+    // we don't accelerate to insanely high speeds.
+}
+```
+
+- **Localization**
+
+  - ⚠️ Started work by integrating `bevy_device_lang`. Requires a proper system that saves this value and allows the player to change it in the game menu, and also requires starting work on localization and saving and loading settings.
+
+- **`bevy_asepritesheet` + `bevy_ecs_ldtk` integration.**
+
+- **Patrol**
+
+  - Flip sprite when turning around!
+
+- **Movement Improvements**
+  - Movement animations.
+  - Movement particle effects.
+  - Coyote (Grace) Time after falling off a ledge.
+    - Maybe needs a raycast in front of the player? Timer needs to start before falling off a ledge.
+  - **Jump Improvements**
+    - Jumping animations.
+    - Jumping particle effects.
+    - Wall Jumping
+      - ~~Prevent player movement for a short duration during the wall jump.~~ Reduce run force? Maybe a lerp between the wall jump speed and running speed?
+    - Air Time
+    - Jump Height
+      - Increase the player's jump height the longer the jump button is being held down.
+    - Clamp maximum falling speed.
+    - Coyote Time while jumping and pressing the jump button.
+      - There is already some check for being in the air we just need the input part I think.
+    - Bonus Air Time
+    - Peak Control
+    - Fast Fall
+      - Increase Player's falling speed after the peak of their jump by adjusting gravity.
+- **Game Feel Improvements**
+
+  This is kinda broad but always iterate over every small mechanic towards more fun.
+
+- **AI Stuff** ⚠️ Started work
+
+  - Pass player input(s) to ai-brain so it can use it for prediction.
+  - Basic Timer with Action Scheduling
+    - Thirst ✅
+    - Fatigue ⚠️
+
+- **Pathfinding** ⚠️ Started work
+- Use something to copy `dxil.dll` and `dxcompiler.dll` to Windows builds.
+- **YarnSpinner**
+  - Begin YarnSpinner integration ✅
+  - YarnSpinner+LDTK integration ⚠️ Started work
+- **UI**
+  - sickle_ui
+    - labels ✅
+    - keycap/gamepad button switching ⚠️
+
+## `filesystem_watcher` and `asset_processor`
+
+???
+
+## Rust Things 🦀
+
+---
+
+### Run in Wolf Mode (Debug)
+
+```pwsh
+cargo run --profile awoo 2>&1 | Out-String -Stream | Where-Object { $_ -notmatch "ID3D12Device::CreateCommittedResource:" -and $_ -notmatch "Live Object at" -and $_ -notmatch "LineGizmo" -and $_ -notmatch "End of Frame" -and $_ -notmatch "prepare_windows" -and $_ -notmatch "cleanup" -and $_ -notmatch "SwapChain" -and $_ -notmatch "create_view" }
+```
+
+### Pedantic linting
+
+```bash
+cargo clippy -- -W clippy::pedantic
+```
+
+### Linting on all packages, treating warnings as errors
+
+```bash
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+```
+
+This command runs the `clippy` linter on all packages in the workspace, for all targets and features. The `-D warnings` option treats any warnings as errors.
+
+### Format code
+
+```bash
+cargo fmt --all
+```
+
+This command formats the code in every package using the default formatting rules provided by `rustfmt`.
+
+### Test without default features
+
+```bash
+cargo test --no-default-features
+```
+
+This command runs tests in the package, but disables the default features.
+
+### Test with only the `bevy_ui` features
+
+```bash
+cargo test --no-default-features --features="bevy_ui"
+```
+
+This command runs tests with only the `bevy_ui` feature enabled.
+
+### Test with all features enabled
+
+```bash
+cargo test --all-features
+```
+
+This command runs tests with all features enabled.
+
+### Test with all features enabled on nightly
+
+```bash
+cargo +nightly build --all-features
+```
+
+This command builds the package with all features enabled using the nightly version of the Rust compiler. This is typically used for generating documentation on docs.rs.
+
+### Generate documentation with all features enabled
+
+```bash
+cargo +nightly doc --all-features --no-deps
+```
+
+This command generates documentation for the package with all features enabled, without including dependencies, using the nightly version of the Rust compiler.
+
+## `seldom_state` + `input_manager` Example
+
+```rust
+// In this game, you can move with the left and right arrow keys, and jump with space.
+// `input-manager` handles the input.
+
+use bevy::prelude::*;
+use input_manager::{ axislike::VirtualAxis, prelude::* };
+use seldom_state::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins((DefaultPlugins, InputManagerPlugin::<Action>::default(), StateMachinePlugin))
+        .add_systems(Startup, init)
+        .add_systems(Update, (walk, fall))
+        .run();
+}
+
+const JUMP_VELOCITY: f32 = 500.0;
+
+fn init(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn(Camera2dBundle::default());
+
+    commands.spawn((
+        SpriteBundle {
+            transform: Transform::from_xyz(500.0, 0.0, 0.0),
+            texture: asset_server.load("player.png"),
+            ..default()
+        },
+        // From `input-manager`
+        InputManagerBundle {
+            input_map: InputMap::default()
+                .insert(Action::Move, VirtualAxis::horizontal_arrow_keys())
+                .insert(Action::Move, SingleAxis::symmetric(GamepadAxisType::LeftStickX, 0.0))
+                .insert(Action::Jump, KeyCode::Space)
+                .insert(Action::Jump, GamepadButtonType::South)
+                .build(),
+            ..default()
+        },
+        // This state machine achieves a very rigid movement system. Consider a state machine for
+        // whatever parts of your player controller that involve discrete states. Like the movement
+        // in Castlevania and Celeste, and the attacks in a fighting game.
+        StateMachine::default()
+            // Whenever the player presses jump, jump
+            .trans::<Grounded, _>(just_pressed(Action::Jump), Falling {
+                velocity: JUMP_VELOCITY,
+            })
+            // When the player hits the ground, idle
+            .trans::<Falling, _>(grounded, Grounded::Idle)
+            // When the player is grounded, set their movement direction
+            .trans_builder(value_unbounded(Action::Move), |_: &Grounded, value| {
+                Some(match value {
+                    value if value > 0.5 => Grounded::Right,
+                    value if value < -0.5 => Grounded::Left,
+                    _ => Grounded::Idle,
+                })
+            }),
+        Grounded::Idle,
+    ));
+}
+
+#[derive(Actionlike, Clone, Eq, Hash, PartialEq, Reflect)]
+enum Action {
+    Move,
+    Jump,
+}
+
+fn grounded(In(entity): In<Entity>, fallings: Query<(&Transform, &Falling)>) -> bool {
+    let (transform, falling) = fallings.get(entity).unwrap();
+    transform.translation.y <= 0.0 && falling.velocity <= 0.0
+}
+
+#[derive(Clone, Copy, Component, Reflect)]
+#[component(storage = "SparseSet")]
+enum Grounded {
+    Left = -1,
+    Idle = 0,
+    Right = 1,
+}
+
+#[derive(Clone, Component, Reflect)]
+#[component(storage = "SparseSet")]
+struct Falling {
+    velocity: f32,
+}
+
+const PLAYER_SPEED: f32 = 200.0;
+
+fn walk(mut groundeds: Query<(&mut Transform, &Grounded)>, time: Res<Time>) {
+    for (mut transform, grounded) in &mut groundeds {
+        transform.translation.x += (*grounded as i32 as f32) * time.delta_seconds() * PLAYER_SPEED;
+    }
+}
+
+const GRAVITY: f32 = -1000.0;
+
+fn fall(mut fallings: Query<(&mut Transform, &mut Falling)>, time: Res<Time>) {
+    for (mut transform, mut falling) in &mut fallings {
+        let dt = time.delta_seconds();
+        falling.velocity += dt * GRAVITY;
+        transform.translation.y += dt * falling.velocity;
+    }
+}
+```

build.rs

@@ -0,0 +1,11 @@
+// Used to embed resources like files or binaries into the executable.
+extern crate embed_resource;
+use std::env;
+
+fn main() {
+    let target = env::var("TARGET").unwrap();
+    if target.contains("windows") {
+        // Sets the game icon in the executable for Windows.
+        embed_resource::compile("build/windows/icon.rc", embed_resource::NONE);
+    }
+}

build/windows/icon.rc

@@ -0,0 +1 @@
+app_icon ICON "icon.ico"

docs/.gitignore

@@ -0,0 +1,3 @@
+# Ignore everything that is not a `.dot` in the graphs directory.
+/graphs/*.png
+/graphs/*.svg

docs/Compilation Options.md

@@ -0,0 +1,55 @@
+# Compilation Options
+
+---
+
+## Render Engine Graphs
+
+---
+
+You can render graphs of the engine if you set the `RENDER_GRAPHS` environment variable `true`. By default it will output `.dot`, `.svg` and `.png` formats for each possible graphs in the `./docs/graph` folder, but it takes a long time so only do this if you like looking at game engines naked!
+
+Bash:
+
+```bash
+RENDER_GRAPHS=true cargo run
+```
+
+PowerShell:
+
+```pwsh
+$env:RENDER_GRAPHS = "true"
+cargo run
+```
+
+## Tracing
+
+---
+
+Bash:
+
+```bash
+$env:RUST_LOG="trace" && cargo run --release --features "bevy/trace_tracy"
+```
+
+PowerShell:
+
+```pwsh
+$env:RUST_LOG="trace"
+cargo run --release --features bevy/trace_tracy
+```
+
+## Filter out DX12 spam with PowerShell
+
+---
+
+PowerShell:
+
+```pwsh
+cargo run 2>&1 | Out-String -Stream | Where-Object { $_ -notmatch "ID3D12Device" -and $_ -notmatch "Live Object at" }
+```
+
+With tracing:
+
+```pwsh
+ cargo run --features bevy/trace_tracy 2>&1 | Out-String -Stream | Where-Object { $_ -notmatch "ID3D12Device" -and $_ -notmatch "Live Object at" }
+ ```

docs/plugins/bevy_device_lang.md

@@ -0,0 +1,20 @@
+# `bevy_device_lang`
+
+---
+
+Provides access device language cross-platform: iOS, Android, Web (Wasm), Windows & Linux. Useful to support app localization in the right language.
+
+Example usages:
+
+```rust
+fn bevy_system() {
+    let lang : Option<String> = bevy_device_lang::get_lang();
+    // ..
+}
+
+fn get_device_language() {
+    info!("Device language is {:?}", bevy_device_lang::get_lang());
+}
+
+    add_systems(Startup, get_device_language)
+```

docs/plugins/bevy_ecs_ldtk.md

@@ -0,0 +1,79 @@
+# `bevy_ecs_ldtk`
+
+---
+
+## Customizing LDtk entities
+
+---
+
+The spawning of entities can be customized by registering a bundle that will be used for spawning the entity. The bundle struct must implement the `LdtkEntity` trait:
+
+```rust
+#[derive(Clone, Default, Bundle, LdtkEntity)]
+pub struct PlayerBundle {
+    #[sprite_bundle("player.png")]
+    pub sprite_bundle: SpriteBundle,
+    #[from_entity_instance]
+    pub collider_bundle: ColliderBundle,
+    pub player: Player,
+    #[worldly]
+    pub worldly: Worldly,
+}
+
+fn my_plugin(app: &mut App) {
+    // Registers PlayerBundle to be spawned for a given Entity identifier
+    app.register_ldtk_entity::<PlayerBundle>("Player");
+}
+```
+
+The `LdtkEntity` trait can either be derived manually or using the derive macro as in the above example. Using derive, the fields can be components or bundles. Their instantiation can be customized using:
+
+## `Default` trait
+
+---
+
+All fields must implement the `Default` trait. Implementing it manually lets you configure the initialization. This approach is relevant when:
+
+- All usages of the component/bundle should have the same initial value,
+- The initial value doesn't depend on the LDtk data of the instance.
+
+## `#[with(...)]` and `#[from_entity_instance]`
+
+---
+
+These allow the field to be constructed from an [`&EntityInstance`](https://docs.rs/bevy_ecs_ldtk/latest/bevy_ecs_ldtk/ldtk/struct.EntityInstance.html), enabling access to the data of the instance (e.g., identifier, fields, pivot, etc.).
+`#[with(...)]` allows specifying a `fn (entity: &EntityInstance) -> T` user function that will construct the field `T` from the `&EntityInstance`. `#[from_entity_instance]` is similar but uses the `From<&EntityInstance>` trait of the field, which should provide a `fn from(entity: &EntityInstance) -> T` function for constructing the field.
+
+## Special components
+
+---
+
+Some sprite and LDtk components have predefined instantiation methods:
+
+- `SpriteBundle` can be initialized using the [`#[sprite_bundle(...)]`](https://docs.rs/bevy_ecs_ldtk/latest/bevy_ecs_ldtk/app/trait.LdtkEntity.html#sprite_bundle) tag. See the player example.
+- Similarly, `SpriteSheetBundle` can be initialized by specifying the [`#[sprite_sheet_bundle("path/to/asset.png", tile_width, tile_height, columns, rows, padding, offset, index)]`](https://docs.rs/bevy_ecs_ldtk/latest/bevy_ecs_ldtk/app/trait.LdtkEntity.html#sprite_sheet_bundle) tag.
+- Both of the above tags will use data from the visual editor if no path or sheet coordinate are specified: `#[sprite_bundle]` and `#[sprite_sheet_bundle]`.
+- `#[worldly] worldly: Worldly,` will attach a special component specifying that the entity should not be despawned when their level despawns.
+- `#[grid_coords] grid_coords: GridCoords,` attach a component containing the initial grid position of the component.
+
+## Manually implementing `LdtkEntity`
+
+---
+
+For advanced usage, the `LdtkEntity` trait can be manually implemented, defining the constructor function:
+
+```rust
+impl LdtkEntity for MyComponentOrBundle {
+    fn bundle_entity(
+        entity_instance: &EntityInstance,
+        layer_instance: &LayerInstance,
+        tileset: Option<&Handle<Image>>,
+        tileset_definition: Option<&TilesetDefinition>,
+        asset_server: &AssetServer,
+        texture_atlases: &mut Assets<TextureAtlas>
+    ) -> Self
+    { Self { ... } }
+}
+```
+
+The arguments provide everything needed for inspecting the entity (`&EntityInstance`, tile sets), the level layer (`&LayerInstance`), and loading assets (`&AssetServer` and `&mut Assets<TextureAtlas>`).

docs/plugins/bevy_flurx.md

@@ -0,0 +1,103 @@
+# `bevy_flurx`
+
+---
+
+## Spawn and Respawn `flurx` Reactor
+
+---
+
+```rust
+//! This example shows how to toggle [`Reactor`] processing.
+//!
+//! When you press [`KeyCode::Escape`], the box stops rotating.
+//! When you press [`KeyCode::Enter`], the box starts rotating again.
+//!
+//! [`Reactor`]: bevy_flurx::prelude::Reactor
+
+use bevy::DefaultPlugins;
+use bevy::prelude::*;
+
+use bevy_flurx::prelude::*;
+
+#[derive(Component)]
+struct RotateBox;
+
+fn main() {
+    App::new()
+        .add_plugins((DefaultPlugins, FlurxPlugin))
+        .add_systems(Startup, (setup_camera_and_box, spawn_reactor))
+        .add_systems(Update, toggle)
+        .run();
+}
+
+fn setup_camera_and_box(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>
+) {
+    commands.spawn((
+        PbrBundle {
+            mesh: meshes.add(Cuboid::new(1.0, 1.0, 1.0)),
+            material: materials.add(StandardMaterial {
+                base_color: Color::BLUE,
+                ..default()
+            }),
+            ..default()
+        },
+        RotateBox,
+    ));
+    commands.spawn(PointLightBundle {
+        point_light: PointLight {
+            shadows_enabled: true,
+            intensity: 10_000_000.0,
+            range: 100.0,
+            ..default()
+        },
+        transform: Transform::from_xyz(8.0, 16.0, 8.0),
+        ..default()
+    });
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0.0, 0.0, 6.0),
+        ..default()
+    });
+}
+
+fn spawn_reactor(mut commands: Commands) {
+    commands.spawn(
+        Reactor::schedule(|task| async move {
+            task.will(Update, wait::until(rotate_shape)).await;
+        })
+    );
+}
+
+fn rotate_shape(mut shape: Query<&mut Transform, With<RotateBox>>, time: Res<Time>) -> bool {
+    for mut t in shape.iter_mut() {
+        t.rotate_y(time.delta_seconds());
+    }
+    false
+}
+
+fn toggle(
+    mut commands: Commands,
+    reactor: Query<Entity, With<Reactor>>,
+    input: Res<ButtonInput<KeyCode>>
+) {
+    if input.just_pressed(KeyCode::Escape) {
+        if let Ok(entity) = reactor.get_single() {
+            info!("Despawning reactor.");
+            commands.entity(entity).remove::<Reactor>();
+        }
+    }
+
+    if input.just_pressed(KeyCode::Enter) {
+        if reactor.iter().next().is_none() {
+            info!("Spawning reactor.");
+            commands.spawn(
+                Reactor::schedule(|task| async move {
+                    task.will(Update, wait::until(rotate_shape)).await;
+                })
+            );
+        }
+    }
+}
+```

docs/plugins/bevy_rapier2d.md

@@ -0,0 +1,32 @@
+# `bevy_rapier2d`
+
+---
+
+## Default RapierConfiguration
+
+---
+
+```rust
+impl RapierConfiguration {
+    /// Configures rapier with the specified length unit.
+    ///
+    /// See the documentation of [`IntegrationParameters::length_unit`] for additional details
+    /// on that argument.
+    ///
+    /// The default gravity is automatically scaled by that length unit.
+    pub fn new(length_unit: Real) -> Self {
+        Self {
+            gravity: Vect::Y * -9.81 * length_unit,
+            physics_pipeline_active: true,
+            query_pipeline_active: true,
+            timestep_mode: TimestepMode::Variable {
+                max_dt: 1.0 / 60.0,
+                time_scale: 1.0,
+                substeps: 1,
+            },
+            scaled_shape_subdivision: 10,
+            force_update_from_transform_changes: false,
+        }
+    }
+}
+```

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"

scripts/Run-Debug.ps1

@@ -0,0 +1,28 @@
+# Define a function to colorize each line based on the log level
+function Colorize-Output {
+	param([string]$Text)
+
+	if ($Text -match "DEBUG") {
+		Write-Host $Text -ForegroundColor Magenta
+	}
+	elseif ($Text -match "INFO") {
+		Write-Host $Text -ForegroundColor Blue
+	}
+	elseif ($Text -match "ERROR") {
+		Write-Host $Text -ForegroundColor Red
+	}
+	elseif ($Text -match "WARN") {
+		Write-Host $Text -ForegroundColor Yellow
+	}
+	elseif ($Text -match "TRACE") {
+		Write-Host $Text -ForegroundColor Cyan
+	}
+	else {
+		Write-Host $Text
+	}
+}
+
+# Run the command, filter the output, and pipe it to the colorizing function
+cargo run 2>&1 | Out-String -Stream | Where-Object { $_ -notmatch "ID3D12Device::CreateCommittedResource:" -and $_ -notmatch "Live Object at" } | ForEach-Object {
+	Colorize-Output $_
+}

scripts/Run-Release.ps1

@@ -0,0 +1,28 @@
+# Define a function to colorize each line based on the log level
+function Colorize-Output {
+	param([string]$Text)
+
+	if ($Text -match "DEBUG") {
+		Write-Host $Text -ForegroundColor Magenta
+	}
+	elseif ($Text -match "INFO") {
+		Write-Host $Text -ForegroundColor Blue
+	}
+	elseif ($Text -match "ERROR") {
+		Write-Host $Text -ForegroundColor Red
+	}
+	elseif ($Text -match "WARN") {
+		Write-Host $Text -ForegroundColor Yellow
+	}
+	elseif ($Text -match "TRACE") {
+		Write-Host $Text -ForegroundColor Cyan
+	}
+	else {
+		Write-Host $Text
+	}
+}
+
+# Run the command, filter the output, and pipe it to the colorizing function
+cargo run --release 2>&1 | Out-String -Stream | Where-Object { $_ -notmatch "ID3D12Device::CreateCommittedResource:" -and $_ -notmatch "Live Object at" } | ForEach-Object {
+	Colorize-Output $_
+}

scripts/Update-Project.ps1

@@ -0,0 +1,2 @@
+git pull
+cargo update

src/components/ai/actions/drink.rs

@@ -0,0 +1,53 @@
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+use crate::components::ai::thirst::Thirst;
+
+#[derive(Reflect, Clone, Component, Debug, ActionBuilder)]
+pub(crate) struct Drink {
+    pub until: f32,
+    pub per_second: f32,
+}
+
+// Action systems execute according to a state machine, where the states are
+// labeled by ActionState.
+pub(crate) fn drink_action_system(
+    time: Res<Time>,
+    mut thirsts: Query<&mut Thirst>,
+    // We execute actions by querying for their associated Action Component
+    // (Drink in this case). You'll always need both Actor and ActionState.
+    mut query: Query<(&Actor, &mut ActionState, &Drink, &ActionSpan)>
+) {
+    for (Actor(actor), mut state, drink, span) in &mut query {
+        // This sets up the tracing scope. Any `debug` calls here will be
+        // spanned together in the output.
+        let _guard = span.span().enter();
+
+        // Use the drink_action's actor to look up the corresponding Thirst Component.
+        if let Ok(mut thirst) = thirsts.get_mut(*actor) {
+            match *state {
+                ActionState::Requested => {
+                    debug!("Time to drink some water!");
+                    *state = ActionState::Executing;
+                }
+                ActionState::Executing => {
+                    trace!("Drinking...");
+                    thirst.thirst -=
+                        drink.per_second * ((time.delta().as_micros() as f32) / 1_000_000.0);
+                    if thirst.thirst <= drink.until {
+                        // To "finish" an action, we set its state to Success or
+                        // Failure.
+                        debug!("Done drinking water");
+                        *state = ActionState::Success;
+                    }
+                }
+                // All Actions should make sure to handle cancellations!
+                ActionState::Cancelled => {
+                    debug!("Action was cancelled. Considering this a failure.");
+                    *state = ActionState::Failure;
+                }
+                _ => {}
+            }
+        }
+    }
+}

src/components/ai/actions/mod.rs

@@ -0,0 +1,6 @@
+// In most cases, the ActionBuilder just attaches the Action component to the
+// actor entity. In this case, you can use the derive macro `ActionBuilder`
+// to make your Action Component implement the ActionBuilder trait.
+// You need your type to implement Clone and Debug (necessary for ActionBuilder)
+
+pub(crate) mod drink;

src/components/ai/mod.rs

@@ -0,0 +1,52 @@
+// 🧠 - AI
+
+// Not to be confused by an actual LLM!
+
+pub(crate) mod actions;
+pub(crate) mod scorers;
+
+// Components
+pub(crate) mod thirst;
+
+use bevy::prelude::*;
+
+use big_brain::prelude::{ FirstToScore, Thinker };
+
+use crate::components::ai::{ actions::drink::Drink, scorers::thirsty::Thirsty, thirst::Thirst };
+
+// Now that we have all that defined, it's time to add a Thinker to an entity!
+// The Thinker is the actual "brain" behind all the AI. Every entity you want
+// to have AI behavior should have one *or more* Thinkers attached to it.
+pub(crate) fn setup(mut cmd: Commands) {
+    // Create the entity and throw the Thirst component in there. Nothing special here.
+    // Neutral AI Brain
+    cmd.spawn((
+        Thirst::new(75.0, 1.6),
+        Thinker::build()
+            .label("NeutralAIBrain")
+            .picker(FirstToScore { threshold: 0.8 })
+            // Technically these are supposed to be ActionBuilders and
+            // ScorerBuilders, but our Clone impls simplify our code here.
+            .when(Thirsty, Drink {
+                until: 1.0,
+                per_second: 5.0,
+            }),
+        // ⚠️ TODO:
+        // When damaged by the player, become hostile.
+    ));
+
+    // AggressiveAIBrain
+    cmd.spawn((
+        Thirst::new(75.0, 1.6),
+        Thinker::build()
+            .label("AggressiveAIBrain")
+            .picker(FirstToScore { threshold: 0.8 })
+            .when(Thirsty, Drink {
+                until: 1.0,
+                per_second: 5.0,
+            }),
+        // ⚠️ TODO:
+        // When player is in line of sight and at the proper
+        // aggro radius, engage in combat.
+    ));
+}

src/components/ai/scorers/mod.rs

@@ -0,0 +1,11 @@
+// These are special components that
+// run in the background, calculating a "Score" value, which is what Big Brain
+// will use to pick which Actions to execute.
+//
+// Just like with Actions, there is a distinction between Scorer components
+// and the ScorerBuilder which will attach those components to the Actor entity.
+//
+// Again, in most cases, you can use the `ScorerBuilder` derive macro to make your
+// Scorer Component act as a ScorerBuilder. You need it to implement Clone and Debug.
+
+pub(crate) mod thirsty;

src/components/ai/scorers/thirsty.rs

@@ -0,0 +1,34 @@
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+use crate::components::ai::thirst::Thirst;
+
+#[derive(Clone, Component, Debug, ScorerBuilder)]
+pub(crate) struct Thirsty;
+
+// Then, we have something called "Scorers".
+
+// Looks familiar? It's a lot like Actions!
+pub(crate) fn thirsty_scorer_system(
+    thirsts: Query<&Thirst>,
+    // Same dance with the Actor here, but now we use look up Score instead of ActionState.
+    mut query: Query<(&Actor, &mut Score, &ScorerSpan), With<Thirsty>>
+) {
+    for (Actor(actor), mut score, span) in &mut query {
+        if let Ok(thirst) = thirsts.get(*actor) {
+            // This is really what the job of a Scorer is. To calculate a
+            // generic "Utility" score that the Big Brain engine will compare
+            // against others, over time, and use to make decisions. This is
+            // generally "the higher the better", and "first across the finish
+            // line", but that's all configurable using Pickers!
+            //
+            // The score here must be between 0.0 and 1.0.
+            score.set(thirst.thirst / 100.0);
+            if thirst.thirst >= 80.0 {
+                span.span().in_scope(|| {
+                    debug!("Thirst above threshold! Score: {}", thirst.thirst / 100.0)
+                });
+            }
+        }
+    }
+}

src/components/ai/thirst.rs

@@ -0,0 +1,30 @@
+use bevy::prelude::*;
+
+// First, we define a "Thirst" component and associated system. This is NOT
+// THE AI. It's a plain old system that just makes an entity "thirstier" over
+// time. This is what the AI will later interact with.
+//
+// There's nothing special here. It's a plain old Bevy component.
+#[derive(Component, Debug, Reflect)]
+pub(crate) struct Thirst {
+    pub per_second: f32,
+    pub thirst: f32,
+}
+
+impl Thirst {
+    pub fn new(thirst: f32, per_second: f32) -> Self {
+        Self { thirst, per_second }
+    }
+}
+
+pub(crate) fn thirst_system(time: Res<Time>, mut thirsts: Query<&mut Thirst>) {
+    for mut thirst in &mut thirsts {
+        thirst.thirst += thirst.per_second * ((time.delta().as_micros() as f32) / 1_000_000.0);
+        if thirst.thirst >= 100.0 {
+            debug!("Thirst >= {}", thirst.thirst);
+            thirst.thirst = 100.0;
+        }
+
+        trace!("Thirst: {}", thirst.thirst);
+    }
+}

src/components/animals.rs

@@ -0,0 +1,127 @@
+use bevy::prelude::*;
+
+// ⚠️ NOTE: Port to bevy_rand somehow.
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+
+// 🐾
+
+// Animal types
+#[derive(Component, PartialEq, Eq)]
+pub enum AnimalType {
+    Cat,
+    Dog,
+}
+
+pub trait Animal: Component {
+    // A static method that returns a static string reference, representing the species of the animal
+    fn species() -> &'static str;
+
+    // A method that returns a reference to a String, representing the name of the animal
+    fn name(&self) -> &String;
+
+    // A method that returns an Option containing a static string reference, representing the gender of the animal
+    fn gender(&self) -> Option<&'static str> {
+        // Get the name of the animal
+        let name = self.name();
+
+        // Iterate over the ANIMAL_NAMES array
+        for &(animal_name, gender, _) in ANIMAL_NAMES {
+            // If the name of the animal matches the name in the array
+            if animal_name == name {
+                // Return the gender of the animal
+                return Some(gender);
+            }
+        }
+
+        // If no match is found, return None
+        None
+    }
+}
+
+// Function to generate an animal name based on the given animal type
+fn generate_animal_name(animal_type: AnimalType) -> String {
+    // Create a random number generator
+    let mut rng = thread_rng();
+
+    // Choose a random animal name from the ANIMAL_NAMES array
+    // The chosen element is a tuple containing the name, gender, and type of the animal
+    match ANIMAL_NAMES.choose(&mut rng) {
+        Some((name, _gender, name_type)) => {
+            // If the type of the chosen animal matches the given animal type
+            if *name_type == animal_type {
+                // Return the name of the animal as a string
+                name.to_string()
+            } else {
+                // If the types don't match, recursively call the function until a matching animal name is found
+                generate_animal_name(animal_type)
+            }
+        }
+        None => {
+            // If the ANIMAL_NAMES array is empty, return a default name
+            "Default Animal Name".to_string()
+        }
+    }
+}
+
+#[rustfmt::skip]
+pub const ANIMAL_NAMES: &[(&str, &str, AnimalType)] = &[
+    ("Malcolm", "male", AnimalType::Dog), ("Zoe", "female", AnimalType::Dog), ("Wash", "male", AnimalType::Dog),
+    ("Inara", "female", AnimalType::Dog), ("Jayne", "male", AnimalType::Dog), ("Kaylee", "female", AnimalType::Dog),
+    ("Simon", "male", AnimalType::Dog), ("River", "female", AnimalType::Dog), ("Book", "male", AnimalType::Dog),
+    ("Saffron", "female", AnimalType::Dog), ("Badger", "male", AnimalType::Dog), ("Nandi", "female", AnimalType::Dog),
+    ("Bester", "male", AnimalType::Dog), ("Dobson", "male", AnimalType::Dog), ("Atherton", "male", AnimalType::Dog),
+    ("Gabriel", "male", AnimalType::Dog), ("Regan", "female", AnimalType::Dog), ("Tracey", "male", AnimalType::Dog),
+    ("Amnon", "male", AnimalType::Dog), ("Fess", "male", AnimalType::Dog), ("Rance", "male", AnimalType::Dog),
+    ("Magistrate", "male", AnimalType::Dog), ("Lucy", "female", AnimalType::Dog), ("Ruth", "female", AnimalType::Dog),
+    ("Bree", "female", AnimalType::Dog), ("Jubal", "male", AnimalType::Dog), ("Fanty", "male", AnimalType::Dog),
+    ("Mingo", "male", AnimalType::Dog), ("Durin", "male", AnimalType::Dog), ("Bridget", "female", AnimalType::Dog),
+    ("Matty", "male", AnimalType::Dog), ("Ranse", "male", AnimalType::Dog), ("Heinrich", "male", AnimalType::Dog),
+    ("Lawrence", "male", AnimalType::Dog), ("Lund", "male", AnimalType::Dog), ("Monty", "male", AnimalType::Dog),
+    ("Corbin", "male", AnimalType::Dog), ("Petaline", "female", AnimalType::Dog), ("Helen", "female", AnimalType::Dog),
+    ("Fanti", "male", AnimalType::Dog), ("Kess", "female", AnimalType::Dog), ("Ransome", "male", AnimalType::Dog),
+    ("Sanda", "female", AnimalType::Dog), // End of 🐕
+    ("Picard", "male", AnimalType::Cat), ("Beverly", "female", AnimalType::Cat), ("Data", "male", AnimalType::Cat),
+    ("Troi", "female", AnimalType::Cat), ("Laforge", "male", AnimalType::Cat), ("Crusher", "male", AnimalType::Cat),
+    ("Yar", "female", AnimalType::Cat), ("Kirk", "male", AnimalType::Cat), ("Spock", "male", AnimalType::Cat),
+    ("Mccoy", "male", AnimalType::Cat), ("Scotty", "male", AnimalType::Cat), ("Uhura", "female", AnimalType::Cat),
+    ("Sulu", "male", AnimalType::Cat), ("Chekov", "male", AnimalType::Cat), ("Chakotay", "male", AnimalType::Cat),
+    ("Tuvok", "male", AnimalType::Cat), ("Sisko", "male", AnimalType::Cat), ("Kira", "female", AnimalType::Cat),
+    ("Dax", "female", AnimalType::Cat), ("Bashir", "male", AnimalType::Cat), ("Odo", "male", AnimalType::Cat),
+    ("Quark", "male", AnimalType::Cat), ("Archer", "male", AnimalType::Cat), ("Tucker", "male", AnimalType::Cat),
+    ("Tpol", "female", AnimalType::Cat), ("Reed", "male", AnimalType::Cat), ("Mayweather", "male", AnimalType::Cat),
+    ("Phlox", "male", AnimalType::Cat), ("Sato", "female", AnimalType::Cat), ("Sevenofnine", "female", AnimalType::Cat),
+    ("Doctor", "male", AnimalType::Cat), ("Paris", "male", AnimalType::Cat), ("Harrykim", "male", AnimalType::Cat),
+    ("Belanna", "female", AnimalType::Cat), ("Torres", "female", AnimalType::Cat), ("Jeanluc", "male", AnimalType::Cat),
+    ("Lorca", "male", AnimalType::Cat), ("Burnham", "female", AnimalType::Cat), ("Saru", "male", AnimalType::Cat),
+    ("Stamets", "male", AnimalType::Cat), ("Tilly", "female", AnimalType::Cat), ("Georgiou", "female", AnimalType::Cat), 
+    ("Culber", "male", AnimalType::Cat), ("Cornwell", "female", AnimalType::Cat), ("Leland", "male", AnimalType::Cat),
+    ("Vance", "male", AnimalType::Cat), ("Reno", "female", AnimalType::Cat), ("Booker", "male", AnimalType::Cat),
+    ("Grudge", "female", AnimalType::Cat), ("Shaxs", "male", AnimalType::Cat), ("Detmer", "female", AnimalType::Cat),
+    ("Owosekun", "female", AnimalType::Cat), ("Rhys", "male", AnimalType::Cat), ("Pike", "male", AnimalType::Cat),
+    ("Number One", "male", AnimalType::Cat), ("Laan", "male", AnimalType::Cat), ("Chapel", "female", AnimalType::Cat), 
+    ("Kyle", "male", AnimalType::Cat), ("Vina", "female", AnimalType::Cat), ("Mudd", "male", AnimalType::Cat),
+    ("Garak", "male", AnimalType::Cat), ("Leyton", "male", AnimalType::Cat), ("Ross", "male", AnimalType::Cat),
+    ("Nog", "male", AnimalType::Cat), ("Jake", "male", AnimalType::Cat), ("Seven", "female", AnimalType::Cat),
+    ("Janeway", "female", AnimalType::Cat), ("Tuvix", "male", AnimalType::Cat), ("Neelix", "male", AnimalType::Cat),
+    ("Kes", "female", AnimalType::Cat), ("Carey", "male", AnimalType::Cat), ("Vorik", "male", AnimalType::Cat),
+    ("Wildman", "female", AnimalType::Cat), ("Zahir", "male", AnimalType::Cat), ("Seska", "female", AnimalType::Cat),
+    ("Jonas", "male", AnimalType::Cat), ("Rio", "male", AnimalType::Cat), ("Maxwell", "male", AnimalType::Cat),
+    ("Tryla", "female", AnimalType::Cat), ("Lorian", "male", AnimalType::Cat), ("Icheb", "male", AnimalType::Cat), 
+    ("Q", "male", AnimalType::Cat), ("Guinan", "female", AnimalType::Cat), ("Pulaski", "female", AnimalType::Cat),
+    ("Ro", "female", AnimalType::Cat), ("Hwomyn", "female", AnimalType::Cat), ("Riker", "male", AnimalType::Cat),
+    ("Shelby", "female", AnimalType::Cat), ("Obrien", "male", AnimalType::Cat), ("Keiko", "female", AnimalType::Cat),
+    ("Molly", "female", AnimalType::Cat), ("Kirayoshi", "male", AnimalType::Cat), ("Naomi", "female", AnimalType::Cat),
+    ("Ezri", "female", AnimalType::Cat), ("Kassidy", "female", AnimalType::Cat), ("Leeta", "female", AnimalType::Cat), 
+    ("Nog", "male", AnimalType::Cat), ("Rom", "male", AnimalType::Cat), ("Brunt", "male", AnimalType::Cat),
+    ("Ishka", "female", AnimalType::Cat), ("Worf", "male", AnimalType::Cat), ("Martok", "male", AnimalType::Cat),
+    ("Grilka", "female", AnimalType::Cat), ("Sharan", "male", AnimalType::Cat), ("Alexander", "male", AnimalType::Cat), 
+    ("Kehleyr", "female", AnimalType::Cat), ("Lwaxana", "female", AnimalType::Cat), ("Kamala", "female", AnimalType::Cat),
+    ("Vash", "female", AnimalType::Cat), ("Tasha", "female", AnimalType::Cat), ("Ogawa", "female", AnimalType::Cat),
+    ("Barclay", "male", AnimalType::Cat), ("Maddox", "male", AnimalType::Cat), ("Soong", "male", AnimalType::Cat),
+    ("Juliana", "female", AnimalType::Cat), ("Sela", "female", AnimalType::Cat), ("Toral", "male", AnimalType::Cat),
+    ("Ziyal", "female", AnimalType::Cat), ("Dukat", "male", AnimalType::Cat), ("Damar", "male", AnimalType::Cat), 
+    ("Weyoun", "male", AnimalType::Cat), ("Eddington", "male", AnimalType::Cat), ("Michael", "male", AnimalType::Cat),
+    ("Sarina", "female", AnimalType::Cat), ("Hugh", "male", AnimalType::Cat), ("Lore", "male", AnimalType::Cat),
+    ("Elaurian", "male", AnimalType::Cat), // End of 🐈‍⬛
+];

src/components/animation.rs

@@ -0,0 +1,67 @@
+use bevy::prelude::*;
+
+use super::health::Health;
+
+// 🎞️
+#[derive(Component, Clone)]
+struct AnimationIndices {
+    first: usize, // The first index of the animation
+    last: usize, // The last index of the animation
+    current_index: usize, // The current index of the animation
+}
+
+#[derive(Component, Deref, DerefMut)]
+struct AnimationTimer(Timer); // The timer for the animation
+
+#[derive(Component)]
+struct DeathAnimationPlayed(bool); // A boolean to track if the death animation has been played
+
+// Function to play the death animation for entities with 0 health
+fn play_death_animation(
+    mut query: Query<(&mut AnimationIndices, &Health, &mut DeathAnimationPlayed, &mut TextureAtlas)>
+) {
+    // Iterate over the entities
+    for (mut animation_indices, health, mut death_animation_played, mut atlas) in &mut query {
+        // If the health of the entity is 0 and the death animation has not been played
+        if health.current == 0 && !death_animation_played.0 {
+            // Set the indices for the death animation
+            animation_indices.first = 4;
+            animation_indices.last = 4;
+            animation_indices.current_index = 4;
+            // Update the TextureAtlas index
+            atlas.index = animation_indices.current_index;
+            // Mark the death animation as played
+            death_animation_played.0 = true;
+        }
+    }
+}
+
+// Function to animate the sprite of entities of type T
+fn animate_sprite<T: Component>(
+    time: Res<Time>, // The current time
+    mut query: Query<(&mut AnimationIndices, &mut AnimationTimer, &mut TextureAtlas), With<T>>
+) {
+    // Iterate over the entities
+    for (mut indices, mut timer, mut atlas) in &mut query {
+        // Update the animation timer
+        timer.tick(time.delta());
+        // If the animation timer has just finished
+        if timer.just_finished() {
+            // Update the current index of the animation
+            indices.current_index = if indices.current_index == indices.last {
+                if indices.first == 4 {
+                    // Loop back to the first frame of the death animation
+                    4
+                } else {
+                    // Loop back to the first frame of the animation
+                    indices.first
+                }
+            } else {
+                // Move to the next frame of the animation
+                indices.current_index + 1
+            };
+            // Update the TextureAtlas index
+            atlas.index = indices.current_index;
+        }
+    }
+}

src/components/armor.rs

@@ -0,0 +1,6 @@
+use bevy::prelude::*;
+
+#[derive(Component, Clone, Default)]
+pub struct Armor {
+    pub value: u32, // The armor value of the entity
+}

src/components/camera/fit_inside_current_level.rs

@@ -0,0 +1,72 @@
+use bevy::prelude::*;
+use bevy_ecs_ldtk::{
+    assets::{ LdtkProject, LevelIndices, LevelMetadataAccessor },
+    LevelIid,
+    LevelSelection,
+};
+
+use crate::entities::Player;
+
+const ASPECT_RATIO: f32 = 16.0 / 9.0;
+
+pub fn fit_inside_current_level(
+    mut camera_query: Query<
+        (&mut bevy::render::camera::OrthographicProjection, &mut Transform),
+        Without<Player>
+    >,
+    player_query: Query<&Transform, With<Player>>,
+    level_query: Query<(&Transform, &LevelIid), (Without<OrthographicProjection>, Without<Player>)>,
+    ldtk_projects: Query<&Handle<LdtkProject>>,
+    level_selection: Res<LevelSelection>,
+    ldtk_project_assets: Res<Assets<LdtkProject>>
+) {
+    if let Ok(Transform { translation: player_translation, .. }) = player_query.get_single() {
+        let player_translation = *player_translation;
+
+        let (mut orthographic_projection, mut camera_transform) = camera_query.single_mut();
+
+        for (level_transform, level_iid) in &level_query {
+            let ldtk_project = ldtk_project_assets
+                .get(ldtk_projects.single())
+                .expect("Project should be loaded if level has spawned");
+
+            let level = ldtk_project
+                .get_raw_level_by_iid(&level_iid.to_string())
+                .expect("Spawned level should exist in LDtk project");
+
+            if level_selection.is_match(&LevelIndices::default(), level) {
+                let level_ratio = (level.px_wid as f32) / (level.px_hei as f32);
+                orthographic_projection.viewport_origin = Vec2::ZERO;
+
+                if level_ratio > ASPECT_RATIO {
+                    // level is wider than the screen
+                    let height = ((level.px_hei as f32) / 9.0).round() * 9.0;
+                    let width = height * ASPECT_RATIO;
+                    orthographic_projection.scaling_mode =
+                        bevy::render::camera::ScalingMode::Fixed { width, height };
+                    camera_transform.translation.x = (
+                        player_translation.x -
+                        level_transform.translation.x -
+                        width / 2.0
+                    ).clamp(0.0, (level.px_wid as f32) - width);
+                    camera_transform.translation.y = 0.0;
+                } else {
+                    // level is taller than the screen
+                    let width = ((level.px_wid as f32) / 16.0).round() * 16.0;
+                    let height = width / ASPECT_RATIO;
+                    orthographic_projection.scaling_mode =
+                        bevy::render::camera::ScalingMode::Fixed { width, height };
+                    camera_transform.translation.y = (
+                        player_translation.y -
+                        level_transform.translation.y -
+                        height / 2.0
+                    ).clamp(0.0, (level.px_hei as f32) - height);
+                    camera_transform.translation.x = 0.0;
+                }
+
+                camera_transform.translation.x += level_transform.translation.x;
+                camera_transform.translation.y += level_transform.translation.y;
+            }
+        }
+    }
+}

src/components/camera/mod.rs

@@ -0,0 +1,5 @@
+//! 🎥
+//!
+//! > NOTE: Remember to keep camera updates to PostUpdate!
+
+pub(crate) mod fit_inside_current_level;

src/components/childof.rs

@@ -0,0 +1,18 @@
+use bevy::prelude::*;
+use aery::prelude::*;
+
+use super::name::Name;
+
+#[derive(Relation)]
+pub struct ChildOf;
+
+pub fn debug_children(
+    tree: Query<(&Name, Relations<ChildOf>)>,
+    roots: Query<Entity, Root<ChildOf>>
+) {
+    tree.traverse::<ChildOf>(roots.iter())
+        .track_self()
+        .for_each(|Name(parent), _, Name(child), _| {
+            debug!("{} is the parent of {}", parent, child);
+        });
+}

src/components/climbing.rs

@@ -0,0 +1,59 @@
+use std::collections::HashSet;
+use bevy::prelude::*;
+use bevy_rapier2d::{ dynamics::GravityScale, pipeline::CollisionEvent };
+
+use crate::plugins::rapier_utils::reciprocal_collisions;
+
+// Attach this to any component to allow the player (or any climber entity) to climb up and
+// down on it.
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Default, Component)]
+pub struct Climbable;
+
+// Attach this component to any entity to allow them to climb up ladders.
+#[derive(Clone, Eq, PartialEq, Debug, Default, Component)]
+pub struct Climber {
+    pub climbing: bool,
+    pub intersecting_climbables: HashSet<Entity>,
+}
+
+// Checks for collision events between climbers and climbable entities.
+// If a collision starts, the climbable entity is added to the climber’s set of intersecting climbables.
+// If a collision stops, the climbable entity is removed from the set.
+pub fn detect_climb_range(
+    mut climbers: Query<&mut Climber>,
+    climbables: Query<Entity, With<Climbable>>,
+    mut collisions: EventReader<CollisionEvent>
+) {
+    reciprocal_collisions(&mut collisions, move |collider_a, collider_b, _, start| {
+        if
+            let (Ok(mut climber), Ok(climbable)) = (
+                climbers.get_mut(*collider_a),
+                climbables.get(*collider_b),
+            )
+        {
+            if start {
+                climber.intersecting_climbables.insert(climbable);
+            } else {
+                climber.intersecting_climbables.remove(&climbable);
+            }
+            true
+        } else {
+            false
+        }
+    });
+}
+
+// Checks if a climber entity is climbing.
+// If it is, the gravity scale is set to 0.0, effectively ignoring gravity.
+// If the climber is not climbing, the gravity scale is set back to 1.0.
+pub fn ignore_gravity_if_climbing(
+    mut query: Query<(&Climber, &mut GravityScale), Changed<Climber>>
+) {
+    for (climber, mut gravity_scale) in &mut query {
+        if climber.climbing {
+            gravity_scale.0 = 0.0;
+        } else {
+            gravity_scale.0 = 1.0;
+        }
+    }
+}

src/components/collision.rs

@@ -0,0 +1,344 @@
+use bevy::{ prelude::*, utils::HashMap, utils::HashSet, ecs::system::EntityCommands };
+use bevy_ecs_ldtk::{
+    assets::LdtkProject,
+    ldtk::{ loaded_level::LoadedLevel, LayerInstance },
+    EntityInstance,
+    GridCoords,
+    LdtkIntCell,
+    LevelIid,
+};
+use bevy_rapier2d::{
+    dynamics::{ CoefficientCombineRule, GravityScale, LockedAxes, RigidBody, Velocity },
+    geometry::{ Collider, ColliderMassProperties, CollisionGroups, Friction, Group },
+};
+
+use crate::entities::intcells::Wall;
+
+/// Spawns heron collisions for the walls that have just been spawned
+///
+/// Lookup the levels corresponding to the walls that have been spawned, and
+/// associate to them the GridCoords of the walls.
+///
+/// See [`spawn_wall_collision_for_level`] for the actual collider generation
+/// algorithm.
+pub fn spawn_wall_collision(
+    mut commands: Commands,
+    wall_query: Query<(&GridCoords, &Parent), Added<Wall>>,
+    parent_query: Query<&Parent, Without<Wall>>,
+    level_query: Query<(Entity, &LevelIid)>,
+    ldtk_projects: Query<&Handle<LdtkProject>>,
+    ldtk_project_assets: Res<Assets<LdtkProject>>
+) {
+    if wall_query.is_empty() {
+        return;
+    }
+
+    let ldtk_project = ldtk_project_assets
+        .get(ldtk_projects.single())
+        .expect("Project should be loaded if level has spawned");
+
+    // Consider where the walls are
+    // storing them as GridCoords in a HashSet for quick, easy lookup
+    //
+    // The key of this map will be the entity of the level the wall belongs to.
+    // This has two consequences in the resulting collision entities:
+    // 1. it forces the walls to be split along level boundaries
+    // 2. it lets us easily add the collision entities as children of the appropriate level entity
+    let mut level_to_wall_locations: HashMap<Entity, HashSet<GridCoords>> = HashMap::new();
+
+    wall_query.iter().for_each(|(&grid_coords, parent)| {
+        // An intgrid tile's direct parent will be a layer entity, not the level entity
+        // To get the level entity, you need the tile's grandparent.
+        // This is where parent_query comes in.
+        if let Ok(grandparent) = parent_query.get(parent.get()) {
+            level_to_wall_locations.entry(grandparent.get()).or_default().insert(grid_coords);
+        }
+    });
+
+    level_query.iter().for_each(|(level_entity, level_iid)| {
+        if let Some(level_walls) = level_to_wall_locations.get(&level_entity) {
+            let level = ldtk_project
+                .as_standalone()
+                .get_loaded_level_by_iid(&level_iid.to_string())
+                .expect("Spawned level should exist in LDtk project");
+
+            spawn_wall_collision_for_level(level, level_walls, commands.entity(level_entity));
+        }
+    });
+}
+
+/// Spawns heron collisions for the walls of a level
+///
+/// You could just insert a ColliderBundle in to the WallBundle,
+/// but this spawns a different collider for EVERY wall tile.
+/// This approach leads to bad performance.
+///
+/// Instead, by flagging the wall tiles and spawning the collisions later,
+/// we can minimize the amount of colliding entities.
+///
+/// The algorithm used here is a nice compromise between simplicity, speed,
+/// and a small number of rectangle colliders.
+/// In basic terms, it will:
+/// 1. consider where the walls are
+/// 2. combine wall tiles into flat "plates" in each individual row
+/// 3. combine the plates into rectangles across multiple rows wherever possible
+/// 4. spawn colliders for each rectangle
+fn spawn_wall_collision_for_level(
+    level: LoadedLevel,
+    level_walls: &bevy::utils::hashbrown::HashSet<GridCoords>,
+    mut entity_commands: EntityCommands
+) {
+    /// Represents a wide wall that is 1 tile tall
+    /// Used to spawn wall collisions
+    #[derive(Clone, Eq, PartialEq, Debug, Default, Hash)]
+    struct Plate {
+        left: i32,
+        right: i32,
+    }
+
+    /// A simple rectangle type representing a wall of any size
+    struct Rect {
+        left: i32,
+        right: i32,
+        top: i32,
+        bottom: i32,
+    }
+
+    let LayerInstance {
+        c_wid: width,
+        c_hei: height,
+        grid_size,
+        ..
+    } = *level
+        .layer_instances()
+        .iter()
+        .filter(|level| level.identifier == "Collisions")
+        .next()
+        .expect("could not find the Collisions layer");
+
+    // combine wall tiles into flat "plates" in each individual row
+    let mut plate_stack: Vec<Vec<Plate>> = Vec::new();
+
+    for y in 0..height {
+        let mut row_plates: Vec<Plate> = Vec::new();
+        let mut plate_start = None;
+
+        // + 1 to the width so the algorithm "terminates" plates that touch the right edge
+        for x in 0..width + 1 {
+            match (plate_start, level_walls.contains(&(GridCoords { x, y }))) {
+                (Some(s), false) => {
+                    row_plates.push(Plate {
+                        left: s,
+                        right: x - 1,
+                    });
+                    plate_start = None;
+                }
+                (None, true) => {
+                    plate_start = Some(x);
+                }
+                _ => (),
+            }
+        }
+
+        plate_stack.push(row_plates);
+    }
+
+    // combine "plates" into rectangles across multiple rows
+    let mut rect_builder: HashMap<Plate, Rect> = HashMap::new();
+    let mut prev_row: Vec<Plate> = Vec::new();
+    let mut wall_rects: Vec<Rect> = Vec::new();
+
+    // an extra empty row so the algorithm "finishes" the rects that touch the top edge
+    plate_stack.push(Vec::new());
+
+    for (y, current_row) in plate_stack.into_iter().enumerate() {
+        for prev_plate in &prev_row {
+            if !current_row.contains(prev_plate) {
+                // remove the finished rect so that the same plate in the future starts a new rect
+                if let Some(rect) = rect_builder.remove(prev_plate) {
+                    wall_rects.push(rect);
+                }
+            }
+        }
+        for plate in &current_row {
+            rect_builder
+                .entry(plate.clone())
+                .and_modify(|e| {
+                    e.top += 1;
+                })
+                .or_insert(Rect {
+                    bottom: y as i32,
+                    top: y as i32,
+                    left: plate.left,
+                    right: plate.right,
+                });
+        }
+        prev_row = current_row;
+    }
+
+    entity_commands.with_children(|level| {
+        // Spawn colliders for every rectangle..
+        // Making the collider a child of the level serves two purposes:
+        // 1. Adjusts the transforms to be relative to the level for free
+        // 2. the colliders will be despawned automatically when levels unload
+        for wall_rect in wall_rects {
+            level
+                .spawn_empty()
+                .insert(Name::new("wall_collision"))
+                .insert(
+                    Collider::cuboid(
+                        (((wall_rect.right as f32) - (wall_rect.left as f32) + 1.0) *
+                            (grid_size as f32)) /
+                            2.0,
+                        (((wall_rect.top as f32) - (wall_rect.bottom as f32) + 1.0) *
+                            (grid_size as f32)) /
+                            2.0
+                    )
+                )
+                .insert(RigidBody::Fixed)
+                .insert(Friction::new(1.0))
+                .insert(
+                    Transform::from_xyz(
+                        (((wall_rect.left + wall_rect.right + 1) as f32) * (grid_size as f32)) /
+                            2.0,
+                        (((wall_rect.bottom + wall_rect.top + 1) as f32) * (grid_size as f32)) /
+                            2.0,
+                        0.0
+                    )
+                )
+                .insert(GlobalTransform::default());
+        }
+    });
+}
+
+#[derive(Clone, Default, Bundle, LdtkIntCell)]
+pub struct ColliderBundle {
+    pub collider: Collider,
+    pub rigid_body: RigidBody,
+    pub velocity: Velocity,
+    pub rotation_constraints: LockedAxes,
+    pub gravity_scale: GravityScale,
+    pub friction: Friction,
+    pub density: ColliderMassProperties,
+    pub collision_group: CollisionGroups,
+}
+
+const PLAYER_GROUP: Group = Group::GROUP_1;
+const NPC_GROUP: Group = Group::GROUP_2;
+
+impl From<&EntityInstance> for ColliderBundle {
+    fn from(entity_instance: &EntityInstance) -> ColliderBundle {
+        let rotation_constraints = LockedAxes::ROTATION_LOCKED;
+
+        match entity_instance.identifier.as_ref() {
+            "Player" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(8.0, 12.0),
+                    friction: Friction {
+                        coefficient: 0.0,
+                        combine_rule: CoefficientCombineRule::Min,
+                    },
+                    rotation_constraints,
+                    collision_group: CollisionGroups::new(PLAYER_GROUP, Group::ALL - NPC_GROUP),
+                    ..Default::default()
+                },
+            "Enemy" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    ..Default::default()
+                },
+            "Npc" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL - NPC_GROUP),
+                    ..Default::default()
+                },
+            "NpcPatrol" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "Cauldron" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "Kade" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "Dog" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "DogPatrol" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "Cat" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "CatPatrol" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(12.0, 12.0),
+                    rigid_body: RigidBody::KinematicVelocityBased,
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    collision_group: CollisionGroups::new(NPC_GROUP, Group::ALL),
+                    ..Default::default()
+                },
+            "Chest" =>
+                ColliderBundle {
+                    collider: Collider::cuboid(8.0, 8.0),
+                    rotation_constraints,
+                    density: ColliderMassProperties::Density(50.0),
+                    ..default()
+                },
+            _ => {
+                debug!("default ColliderBundle used for: {}", entity_instance.identifier);
+                ColliderBundle {
+                    collider: Collider::cuboid(
+                        (entity_instance.width as f32) / 2.0,
+                        (entity_instance.height as f32) / 2.0
+                    ),
+                    rotation_constraints,
+                    ..default()
+                }
+            }
+        }
+    }
+}

src/components/deathzone.rs

@@ -0,0 +1,5 @@
+use bevy::prelude::*;
+
+// 💀 Zone
+#[derive(Component)]
+pub struct DeathZone;

src/components/ground.rs

@@ -0,0 +1,75 @@
+use bevy::{ prelude::*, utils::HashSet };
+use bevy_rapier2d::{ geometry::{ ActiveEvents, Collider, Sensor }, pipeline::CollisionEvent };
+
+use crate::plugins::rapier_utils::reciprocal_collisions;
+
+#[derive(Clone, Default, Component)]
+pub struct GroundDetection {
+    pub on_ground: bool,
+}
+
+#[derive(Component)]
+pub struct GroundSensor {
+    pub ground_detection_entity: Entity,
+    pub intersecting_ground_entities: HashSet<Entity>,
+}
+
+pub fn spawn_ground_sensor(
+    mut commands: Commands,
+    detect_ground_for: Query<(Entity, &Collider), Added<GroundDetection>>
+) {
+    for (entity, shape) in &detect_ground_for {
+        if let Some(cuboid) = shape.as_cuboid() {
+            let Vec2 { x: half_extents_x, y: half_extents_y } = cuboid.half_extents();
+
+            let detector_shape = Collider::cuboid(half_extents_x / 2.0, 2.0);
+
+            let sensor_translation = Vec3::new(0.0, -half_extents_y, 0.0);
+
+            commands.entity(entity).with_children(|builder| {
+                builder
+                    .spawn_empty()
+                    .insert(Name::new("ground_sensor"))
+                    .insert(ActiveEvents::COLLISION_EVENTS)
+                    .insert(detector_shape)
+                    .insert(Sensor)
+                    .insert(Transform::from_translation(sensor_translation))
+                    .insert(GlobalTransform::default())
+                    .insert(GroundSensor {
+                        ground_detection_entity: entity,
+                        intersecting_ground_entities: HashSet::new(),
+                    });
+            });
+        }
+    }
+}
+
+pub fn ground_detection(
+    mut ground_sensors: Query<&mut GroundSensor>,
+    mut collisions: EventReader<CollisionEvent>,
+    collidables: Query<Entity, (With<Collider>, Without<Sensor>)>
+) {
+    reciprocal_collisions(&mut collisions, move |e1, e2, _, start| {
+        if let (true, Ok(mut sensor)) = (collidables.contains(*e1), ground_sensors.get_mut(*e2)) {
+            if start {
+                sensor.intersecting_ground_entities.insert(*e1);
+            } else {
+                sensor.intersecting_ground_entities.remove(e1);
+            }
+            true
+        } else {
+            false
+        }
+    });
+}
+
+pub fn update_on_ground(
+    mut ground_detectors: Query<&mut GroundDetection>,
+    ground_sensors: Query<&GroundSensor, Changed<GroundSensor>>
+) {
+    for sensor in &ground_sensors {
+        if let Ok(mut ground_detection) = ground_detectors.get_mut(sensor.ground_detection_entity) {
+            ground_detection.on_ground = !sensor.intersecting_ground_entities.is_empty();
+        }
+    }
+}

src/components/health.rs

@@ -0,0 +1,32 @@
+use bevy::{ ecs::component::Component, reflect::Reflect };
+
+use super::armor::Armor;
+
+// 🩸
+#[derive(Component, Clone, Reflect)]
+pub struct Health {
+    pub current: u32,
+    pub max: u32,
+    pub hunger: u32,
+}
+
+impl Default for Health {
+    fn default() -> Self {
+        Self {
+            current: 100,
+            max: 100,
+            hunger: 0,
+        }
+    }
+}
+
+impl Health {
+    pub fn take_damage(&mut self, mut damage: u32, armor: Option<&Armor>) {
+        if let Some(armor) = armor {
+            let reduction = ((armor.value as f32) / 100.0) * (damage as f32);
+            damage -= reduction.ceil() as u32;
+        }
+
+        self.current = self.current.saturating_sub(damage);
+    }
+}

src/components/hunger.rs

@@ -0,0 +1,35 @@
+use std::time::Duration;
+
+use bevy::{ ecs::system::{ Query, Res, ResMut, Resource }, time::{ Time, Timer } };
+
+use super::health::Health;
+
+// 🍗
+#[derive(Resource, Default)]
+pub struct HungerTimer(Timer); // A timer to track the hunger of entities
+
+// Function to decrease the hunger of entities over time
+pub fn decrease_hunger(
+    time: Res<Time>, // The current time
+    mut hunger_timer: ResMut<HungerTimer>, // The hunger timer
+    mut health_query: Query<&mut Health> // The health of the entities
+) {
+    // Update the hunger timer
+    hunger_timer.0.tick(time.delta());
+    // If the hunger timer has just finished
+    if hunger_timer.0.just_finished() {
+        // Iterate over the entities
+        for mut health in &mut health_query {
+            // Decrease the hunger of the entity by 1
+            health.hunger = health.hunger.saturating_sub(1);
+            // If the hunger of the entity reaches 0, decrease its health by 1
+            if health.hunger == 0 {
+                health.current = health.current.saturating_sub(1);
+            }
+        }
+        // Set the duration of the hunger timer to 20 seconds
+        hunger_timer.0.set_duration(Duration::from_secs(20));
+        // Reset the hunger timer to count down again
+        hunger_timer.0.reset();
+    }
+}

src/components/interactions.rs

@@ -0,0 +1,152 @@
+use std::collections::HashSet;
+
+use bevy::{
+    core::Name,
+    render::color::Color,
+    ecs::{
+        component::Component,
+        entity::Entity,
+        event::EventReader,
+        query::{ Added, With },
+        system::{ Commands, Query },
+    },
+    hierarchy::{ Parent, PushChild },
+    log,
+    math::Vec2,
+    transform::components::GlobalTransform,
+};
+use bevy_ecs_ldtk::{ ldtk::ldtk_fields::LdtkFields, EntityInstance };
+use bevy_rapier2d::{ geometry::{ ActiveEvents, Collider, Sensor }, pipeline::CollisionEvent };
+
+use crate::entities::Player;
+use crate::plugins::rapier_utils::reciprocal_collisions;
+
+#[derive(Component, Default)]
+pub struct InteractionSensor {
+    pub intersecting_entities: HashSet<Entity>,
+    pub closest_entity: Option<Entity>,
+}
+
+/// Spawn a sensing region around the Player.
+///
+/// The sensor is spawn as a children to the Player. It contains an
+/// [`InteractionSensor`] component that tracks interactive entities in range
+/// and the closest one.
+pub(crate) fn spawn_interaction_sensor(
+    mut commands: Commands,
+    mut detect_interaction_for: Query<(Entity, &Collider), Added<Player>>
+) {
+    for (parent, shape) in &mut detect_interaction_for {
+        if let Some(cuboid) = shape.as_cuboid() {
+            let Vec2 { x: half_extents_x, y: half_extents_y } = cuboid.half_extents();
+            let mut sensor_cmds = commands.spawn((
+                ActiveEvents::COLLISION_EVENTS,
+                Collider::cuboid(half_extents_x * 4.0, half_extents_y * 1.5),
+                Sensor,
+                InteractionSensor::default(),
+            ));
+            #[cfg(feature = "dev_features")]
+            sensor_cmds.insert((
+                Name::new("interaction_sensor"),
+                bevy_rapier2d::render::ColliderDebugColor(Color::rgb(0.0, 1.0, 0.0)),
+            ));
+            let child = sensor_cmds.id();
+            commands.add(PushChild { parent, child });
+        }
+    }
+}
+
+#[derive(Component)]
+pub struct Interactive {
+    pub name: String,
+}
+
+/// Adds the [`Interactive`] component to LDtk entities that have a name and the
+/// `hasDialogue` field set to true
+pub(crate) fn setup_interactive_entity(
+    mut commands: Commands,
+    query: Query<(Entity, &EntityInstance), Added<EntityInstance>>
+) {
+    for (entity, ldtk_entity) in query.iter() {
+        if
+            let (Ok(name), Ok(true)) = (
+                ldtk_entity.get_string_field("name"),
+                ldtk_entity.get_bool_field("hasDialogue"),
+            )
+        {
+            log::debug!("New interactive {}: {}", ldtk_entity.identifier, name);
+            commands.entity(entity).insert(Interactive { name: name.into() });
+        }
+    }
+}
+
+/// System collecting collision events of the interaction sensor with
+/// interactive entities
+pub(crate) fn interaction_detection(
+    mut interaction_sensors: Query<&mut InteractionSensor>,
+    interactive_entities: Query<Entity, With<Interactive>>,
+    mut collisions: EventReader<CollisionEvent>
+) {
+    reciprocal_collisions(&mut collisions, move |interactor_entity, interactive_entity, _, start| {
+        if
+            let (Ok(mut interactor), true) = (
+                interaction_sensors.get_mut(*interactor_entity),
+                interactive_entities.contains(*interactive_entity),
+            )
+        {
+            let set = &mut interactor.intersecting_entities;
+            if start {
+                set.insert(*interactive_entity);
+            } else {
+                set.remove(interactive_entity);
+            }
+            true
+        } else {
+            false
+        }
+    });
+}
+
+/// System that tracks distances between interactive entities and the sensor, in
+/// order to elect the closest interactive entity.
+pub(crate) fn update_interactions(
+    mut interaction_sensors: Query<(&mut InteractionSensor, &Parent)>,
+    player_query: Query<&GlobalTransform, With<Player>>,
+    interactive: Query<(&GlobalTransform, &Collider), With<Interactive>>
+) {
+    for (mut sensor, parent) in &mut interaction_sensors {
+        // Bypass the player transform query if the is no interactive entities
+        // in range
+        if sensor.intersecting_entities.is_empty() {
+            if sensor.closest_entity != None {
+                sensor.closest_entity = None;
+            }
+            continue;
+        }
+        let player_transform = player_query.get(**parent).unwrap();
+        // Find the closest entity.
+        let mut closest_dist = f32::INFINITY;
+        let mut closest_entity = None;
+        for interactive_entity in &sensor.intersecting_entities {
+            let Ok((interactive_transform, interactive_collider)) = interactive.get(
+                *interactive_entity
+            ) else {
+                continue;
+            };
+
+            let distance = interactive_collider.distance_to_local_point(
+                player_transform.reparented_to(interactive_transform).translation.truncate(),
+                false
+            );
+            if distance < closest_dist {
+                closest_dist = distance;
+                closest_entity = Some(*interactive_entity);
+            }
+        }
+        // Gate the mutation such that only real change are detected when using
+        // `Changed<InteractionSensor>` (See `Mut<>` mutation detection)
+        if sensor.closest_entity != closest_entity {
+            sensor.closest_entity = closest_entity;
+        }
+    }
+}

src/components/items.rs

@@ -0,0 +1,34 @@
+use bevy::{
+    input::{ ButtonInput, keyboard::KeyCode },
+    ecs::{ component::Component, system::Res, system::Query, query::With },
+};
+use bevy_ecs_ldtk::{ ldtk::ldtk_fields::LdtkFields, EntityInstance };
+
+use crate::entities::Player;
+
+#[derive(Clone, Component, Debug, Eq, Default, PartialEq)]
+pub struct Items(Vec<String>);
+
+impl From<&EntityInstance> for Items {
+    fn from(entity_instance: &EntityInstance) -> Self {
+        Items(
+            entity_instance
+                .iter_enums_field("items")
+                .expect("items field should be correctly typed")
+                .cloned()
+                .collect()
+        )
+    }
+}
+
+pub fn dbg_player_items(
+    input: Res<ButtonInput<KeyCode>>,
+    mut query: Query<(&Items, &EntityInstance), With<Player>>
+) {
+    for (items, entity_instance) in &mut query {
+        if input.just_pressed(KeyCode::KeyP) {
+            dbg!(&items);
+            dbg!(&entity_instance);
+        }
+    }
+}

src/components/line_of_sight.rs

@@ -0,0 +1,94 @@
+use std::marker::PhantomData;
+
+use bevy::{
+    core::Name,
+    ecs::{ component::Component, entity::Entity, query::With, system::{ Query, Res } },
+    log,
+    math::Vec2,
+    transform::components::GlobalTransform,
+};
+use bevy_rapier2d::{ pipeline::QueryFilter, plugin::RapierContext };
+
+/// Component applied to entities that should detect line of sight to the target
+#[derive(Component, Clone)]
+pub(crate) struct LineOfSight<Target> {
+    max_distance: f32,
+    last_sighted: Option<Vec2>,
+    in_sight: bool,
+    marker: PhantomData<Target>,
+}
+
+/// Component applied to entities that seek the target
+impl<Target> Default for LineOfSight<Target> {
+    fn default() -> Self {
+        Self { max_distance: 250.0, last_sighted: None, in_sight: false, marker: PhantomData }
+    }
+}
+
+pub(crate) fn line_of_sight<Target: Component>(
+    targets: Query<(Entity, &GlobalTransform), With<Target>>,
+    mut observers: Query<(&mut LineOfSight<Target>, &GlobalTransform, Entity, Option<&Name>)>,
+    rapier_context: Res<RapierContext>
+) {
+    for (target_entity, target_transform) in &targets {
+        let target_pos = target_transform.translation().truncate();
+
+        // Iterate over entities having a LineOfSight component
+        for (
+            mut line_of_sight,
+            observer_transform,
+            observer_entity,
+            observer_name,
+        ) in &mut observers {
+            let observer_pos = observer_transform.translation().truncate();
+            let vector = target_pos - observer_pos;
+            let max_distance = line_of_sight.max_distance;
+            let distance = vector.length();
+            if distance > max_distance {
+                continue;
+            }
+            let ray_dir = vector.normalize();
+
+            // Cast ray from the observer toward the target
+            let stalked = if
+                let Some((collided_entity, toi)) = rapier_context.cast_ray(
+                    observer_pos,
+                    ray_dir,
+                    max_distance,
+                    false,
+                    // FIXME: make sight obstacles (wall etc) into a group and use .groups() to only hit target and obstacles
+                    QueryFilter::new().exclude_sensors().exclude_collider(observer_entity)
+                )
+            {
+                // TODO: remove debug
+                if collided_entity == target_entity && !line_of_sight.in_sight {
+                    log::debug!(
+                        "{:?}({:?}) sees the target! toi={}",
+                        observer_name,
+                        observer_entity,
+                        toi
+                    );
+                }
+                collided_entity == target_entity
+            } else {
+                false
+            };
+
+            // Minimal updates
+            if stalked {
+                let last_sighted = Some(target_pos);
+                if !line_of_sight.in_sight || line_of_sight.last_sighted != last_sighted {
+                    let los_mut = line_of_sight.as_mut();
+                    los_mut.last_sighted = last_sighted;
+                    los_mut.in_sight = true;
+                }
+            } else {
+                if line_of_sight.in_sight {
+                    line_of_sight.in_sight = false;
+                    // TODO: remove debug
+                    log::debug!("{:?}({:?}) lost the target.", observer_name, observer_entity);
+                }
+            }
+        }
+    }
+}

src/components/mod.rs

@@ -0,0 +1,20 @@
+pub(crate) mod animals;
+pub(crate) mod health;
+pub(crate) mod collision;
+pub(crate) mod ground;
+pub(crate) mod items;
+pub(crate) mod sensorbundle;
+pub(crate) mod camera;
+pub(crate) mod hunger;
+pub(crate) mod armor;
+pub(crate) mod predefinedpath;
+pub(crate) mod animation;
+pub(crate) mod settings;
+pub(crate) mod interactions;
+pub(crate) mod deathzone;
+pub(super) mod swimming;
+pub(super) mod climbing;
+pub(super) mod line_of_sight;
+pub(super) mod ai;
+pub(super) mod childof;
+pub(super) mod name;

src/components/name.rs

@@ -0,0 +1,4 @@
+use bevy::prelude::*;
+
+#[derive(Component)]
+pub struct Name(pub &'static str);

src/components/predefinedpath.rs

@@ -0,0 +1,107 @@
+use bevy::{
+    asset::{ AssetServer, Assets, Handle },
+    ecs::{ component::Component, system::Query },
+    math::{ IVec2, Vec2 },
+    render::texture::Image,
+    sprite::TextureAtlasLayout,
+    transform::components::Transform,
+};
+use bevy_ecs_ldtk::{
+    ldtk::{ LayerInstance, TilesetDefinition },
+    utils::ldtk_pixel_coords_to_translation_pivoted,
+    EntityInstance,
+    prelude::LdtkEntity,
+    prelude::LdtkFields,
+};
+use bevy_rapier2d::dynamics::Velocity;
+
+#[derive(Clone, PartialEq, Debug, Default, Component)]
+pub struct PredefinedPath {
+    pub points: Vec<Vec2>,
+    pub index: usize,
+    pub forward: bool,
+}
+
+impl LdtkEntity for PredefinedPath {
+    fn bundle_entity(
+        entity_instance: &EntityInstance,
+        layer_instance: &LayerInstance,
+        _: Option<&Handle<Image>>,
+        _: Option<&TilesetDefinition>,
+        _: &AssetServer,
+        _: &mut Assets<TextureAtlasLayout>
+    ) -> PredefinedPath {
+        let mut points = Vec::new();
+        points.push(
+            ldtk_pixel_coords_to_translation_pivoted(
+                entity_instance.px,
+                layer_instance.c_hei * layer_instance.grid_size,
+                IVec2::new(entity_instance.width, entity_instance.height),
+                entity_instance.pivot
+            )
+        );
+
+        let ldtk_path_points = entity_instance
+            .iter_points_field("path")
+            .expect("path field should be correctly typed");
+
+        for ldtk_point in ldtk_path_points {
+            // The +1 is necessary here due to the pivot of the entities in the sample
+            // file.
+            // The paths set up in the file look flat and grounded,
+            // but technically they're not if you consider the pivot,
+            // which is at the bottom-center for the skulls.
+            let pixel_coords =
+                (ldtk_point.as_vec2() + Vec2::new(0.5, 1.0)) *
+                Vec2::splat(layer_instance.grid_size as f32);
+
+            points.push(
+                ldtk_pixel_coords_to_translation_pivoted(
+                    pixel_coords.as_ivec2(),
+                    layer_instance.c_hei * layer_instance.grid_size,
+                    IVec2::new(entity_instance.width, entity_instance.height),
+                    entity_instance.pivot
+                )
+            );
+        }
+
+        PredefinedPath {
+            points,
+            index: 1,
+            forward: true,
+        }
+    }
+}
+
+pub fn move_on_path(mut query: Query<(&mut Transform, &mut Velocity, &mut PredefinedPath)>) {
+    for (mut transform, mut velocity, mut path) in &mut query {
+        if path.points.len() <= 1 {
+            continue;
+        }
+
+        let mut new_velocity =
+            (path.points[path.index] - transform.translation.truncate()).normalize() * 20.0;
+
+        if new_velocity.dot(velocity.linvel) < 0.0 {
+            if path.index == 0 {
+                path.forward = true;
+            } else if path.index == path.points.len() - 1 {
+                path.forward = false;
+            }
+
+            transform.translation.x = path.points[path.index].x;
+            transform.translation.y = path.points[path.index].y;
+
+            if path.forward {
+                path.index += 1;
+            } else {
+                path.index -= 1;
+            }
+
+            new_velocity =
+                (path.points[path.index] - transform.translation.truncate()).normalize() * 20.0;
+        }
+
+        velocity.linvel = new_velocity;
+    }
+}

src/components/sensorbundle.rs

@@ -0,0 +1,37 @@
+use bevy::ecs::bundle::Bundle;
+use bevy_ecs_ldtk::{ IntGridCell, LdtkIntCell };
+use bevy_rapier2d::{ dynamics::LockedAxes, geometry::{ ActiveEvents, Collider, Sensor } };
+
+#[derive(Clone, Default, Bundle, LdtkIntCell)]
+pub struct SensorBundle {
+    pub collider: Collider,
+    pub sensor: Sensor,
+    pub active_events: ActiveEvents,
+    pub rotation_constraints: LockedAxes,
+}
+
+impl From<IntGridCell> for SensorBundle {
+    fn from(int_grid_cell: IntGridCell) -> SensorBundle {
+        let rotation_constraints = LockedAxes::ROTATION_LOCKED;
+
+        // Ladder
+        if int_grid_cell.value == 2 {
+            SensorBundle {
+                collider: Collider::cuboid(8.0, 8.0),
+                sensor: Sensor,
+                rotation_constraints,
+                active_events: ActiveEvents::COLLISION_EVENTS,
+            }
+            // Water
+        } else if int_grid_cell.value == 4 {
+            SensorBundle {
+                collider: Collider::cuboid(8.0, 8.0),
+                sensor: Sensor,
+                rotation_constraints,
+                active_events: ActiveEvents::COLLISION_EVENTS,
+            }
+        } else {
+            SensorBundle::default()
+        }
+    }
+}

src/components/settings.rs

@@ -0,0 +1,84 @@
+use bevy::ecs::change_detection::DetectChanges;
+use bevy::window::{ WindowLevel, PresentMode, PrimaryWindow, WindowMode };
+use bevy::prelude::{ Resource, Res, Query, With, Window };
+
+// GameWindowLevel
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GameWindowLevel {
+    Normal,
+    AlwaysOnTop,
+}
+
+impl From<GameWindowLevel> for WindowLevel {
+    fn from(level: GameWindowLevel) -> Self {
+        match level {
+            GameWindowLevel::Normal => WindowLevel::Normal,
+            GameWindowLevel::AlwaysOnTop => WindowLevel::AlwaysOnTop,
+        }
+    }
+}
+
+// GameVsyncMode
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GameVsyncMode {
+    AutoNoVsync,
+    AutoVsync,
+    Immediate,
+}
+
+impl From<GameVsyncMode> for PresentMode {
+    fn from(mode: GameVsyncMode) -> Self {
+        match mode {
+            GameVsyncMode::AutoNoVsync => PresentMode::AutoNoVsync,
+            GameVsyncMode::AutoVsync => PresentMode::AutoVsync,
+            GameVsyncMode::Immediate => PresentMode::Immediate,
+        }
+    }
+}
+
+// GameWindowMode
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GameWindowMode {
+    Windowed,
+    Fullscreen,
+}
+
+impl From<GameWindowMode> for WindowMode {
+    fn from(mode: GameWindowMode) -> Self {
+        match mode {
+            GameWindowMode::Windowed => WindowMode::Windowed,
+            GameWindowMode::Fullscreen => WindowMode::Fullscreen,
+        }
+    }
+}
+
+// GameSettings
+#[derive(Resource)]
+pub struct GameSettings {
+    pub window_level: GameWindowLevel,
+    pub vsync_mode: GameVsyncMode,
+    pub window_mode: GameWindowMode,
+}
+
+impl Default for GameSettings {
+    fn default() -> Self {
+        Self {
+            window_level: GameWindowLevel::Normal,
+            vsync_mode: GameVsyncMode::AutoVsync,
+            window_mode: GameWindowMode::Fullscreen,
+        }
+    }
+}
+
+pub fn update_window_settings(
+    settings: Res<GameSettings>,
+    mut primary_window: Query<&mut Window, With<PrimaryWindow>>
+) {
+    if settings.is_changed() {
+        if let Ok(mut window) = primary_window.get_single_mut() {
+            window.window_level = settings.window_level.into();
+            window.present_mode = settings.vsync_mode.into();
+            window.mode = settings.window_mode.into();
+        }
+    }
+}

src/components/swimming.rs

@@ -0,0 +1,45 @@
+use std::collections::HashSet;
+use bevy::ecs::{
+    component::Component,
+    entity::Entity,
+    event::EventReader,
+    query::With,
+    system::Query,
+};
+use bevy_rapier2d::pipeline::CollisionEvent;
+
+use crate::plugins::rapier_utils::reciprocal_collisions;
+
+#[derive(Copy, Clone, Eq, PartialEq, Debug, Default, Component)]
+pub struct Swimmable;
+
+// Attach this component to any entity to allow them to swim
+#[derive(Clone, Eq, PartialEq, Debug, Default, Component)]
+pub struct Swimmer {
+    pub swimming: bool,
+    pub intersecting_swimmables: HashSet<Entity>,
+}
+
+pub fn detect_swim_range(
+    mut swimmers: Query<&mut Swimmer>,
+    swimmables: Query<Entity, With<Swimmable>>,
+    mut collisions: EventReader<CollisionEvent>
+) {
+    reciprocal_collisions(&mut collisions, move |collider_a, collider_b, _, start| {
+        if
+            let (Ok(mut swimmer), Ok(swimmable)) = (
+                swimmers.get_mut(*collider_a),
+                swimmables.get(*collider_b),
+            )
+        {
+            if start {
+                swimmer.intersecting_swimmables.insert(swimmable);
+            } else {
+                swimmer.intersecting_swimmables.remove(&swimmable);
+            }
+            true
+        } else {
+            false
+        }
+    });
+}