update readme

Need to wait for asset_loader upate full release
Need to refactor Prefab system to use the new relationships

.github/workflows/ci.yaml

@@ -0,0 +1,140 @@
+name: CI
+
+on:
+    push:
+        branches: [master]
+    pull_request:
+        branches: [master]
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
+    cancel-in-progress: true
+
+env:
+    # Reduce compile time and cache size.
+    RUSTFLAGS: -Zshare-generics=y -Zthreads=0
+    RUSTDOCFLAGS: -Zshare-generics=y -Zthreads=0
+    # Use the same Rust toolchain across jobs so they can share a cache.
+    toolchain: nightly-2025-04-03
+
+jobs:
+    # Run Clippy lints.
+    clippy-lints:
+        name: Clippy lints
+        runs-on: ubuntu-latest
+        env:
+            RUSTFLAGS: "-Dwarnings"
+        timeout-minutes: 20
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Install Rust toolchain
+              uses: dtolnay/rust-toolchain@master
+              with:
+                  toolchain: ${{ env.toolchain }}
+                  components: clippy
+
+            - name: Restore Rust cache
+              id: cache
+              uses: Swatinem/rust-cache@v2
+              with:
+                  shared-key: ci
+                  save-if: ${{ github.ref == 'refs/heads/main' }}
+
+            - name: Install build dependencies
+              if: steps.cache.outputs.cache-hit != 'true'
+              run: sudo apt-get -y update; sudo apt-get -y install --no-install-recommends libasound2-dev libudev-dev libwayland-dev
+
+            - name: Run Clippy lints
+              run: cargo clippy --locked --workspace --all-targets --profile ci --all-features
+
+    # Run Bevy lints.
+    bevy-lints:
+        name: Bevy lints
+        runs-on: ubuntu-latest
+        env:
+            RUSTFLAGS: "-Dwarnings"
+        timeout-minutes: 20
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Install Rust toolchain (plus bevy_lint)
+              uses: TheBevyFlock/bevy_cli/bevy_lint@lint-v0.3.0
+
+            - name: Restore Rust cache
+              id: cache
+              uses: Swatinem/rust-cache@v2
+              with:
+                  shared-key: ci
+                  save-if: false
+
+            - name: Install build dependencies
+              if: steps.cache.outputs.cache-hit != 'true'
+              run: sudo apt-get -y update; sudo apt-get -y install --no-install-recommends libasound2-dev libudev-dev libwayland-dev
+
+            - name: Run Bevy lints
+              run: bevy_lint --locked --workspace --all-targets --profile ci --all-features
+
+    # Run tests.
+    tests:
+        name: Tests
+        runs-on: ubuntu-latest
+        timeout-minutes: 40
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Set up environment
+              run: echo "RUSTFLAGS=${RUSTFLAGS:+$RUSTFLAGS }-Zcodegen-backend=cranelift" >> "${GITHUB_ENV}"
+
+            - name: Install Rust toolchain
+              uses: dtolnay/rust-toolchain@master
+              with:
+                  toolchain: ${{ env.toolchain }}
+                  components: rustc-codegen-cranelift-preview
+
+            - name: Restore Rust cache
+              uses: Swatinem/rust-cache@v2
+              with:
+                  shared-key: test
+                  cache-directories: ${{ env.LD_LIBRARY_PATH }}
+                  save-if: ${{ github.ref == 'refs/heads/main' }}
+
+            - name: Install build dependencies
+              run: sudo apt-get -y update; sudo apt-get -y install --no-install-recommends libasound2-dev libudev-dev libwayland-dev
+
+            - name: Run tests
+              run: cargo test --locked --workspace --all-targets --profile ci --no-fail-fast
+
+    # Check that the web build compiles.
+    # check-web:
+    #     name: Check web
+    #     runs-on: ubuntu-latest
+    #     env:
+    #         RUSTFLAGS: -Zshare-generics=y -Zthreads=0 --cfg getrandom_backend="wasm_js"
+    #     timeout-minutes: 20
+    #     steps:
+    #         - name: Checkout repository
+    #           uses: actions/checkout@v4
+
+    #         - name: Install Rust toolchain
+    #           uses: dtolnay/rust-toolchain@master
+    #           with:
+    #               toolchain: ${{ env.toolchain }}
+    #               targets: wasm32-unknown-unknown
+
+    #         - name: Restore Rust cache
+    #           id: cache
+    #           uses: Swatinem/rust-cache@v2
+    #           with:
+    #               shared-key: web-ci
+    #               save-if: ${{ github.ref == 'refs/heads/main' }}
+
+    #         - name: Install build dependencies
+    #           if: steps.cache.outputs.cache-hit != 'true'
+    #           run: sudo apt-get -y update; sudo apt-get -y install --no-install-recommends libasound2-dev libudev-dev libwayland-dev
+
+    #         - name: Check web
+    #           run: cargo check --config 'profile.web.inherits="dev"' --profile ci --no-default-features --features "dev web" --target wasm32-unknown-unknown

.github/workflows/release.yaml

@@ -0,0 +1,335 @@
+name: Release
+
+on:
+    # Trigger this workflow when a tag is pushed in the format `v1.2.3`.
+    push:
+        tags:
+            # Pattern syntax: <https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet>.
+            - "v[0-9]+.[0-9]+.[0-9]+*"
+    # Trigger this workflow manually via workflow dispatch.
+    workflow_dispatch:
+        inputs:
+            version:
+                description: "Version number in the format `v1.2.3`"
+                required: true
+                type: string
+
+concurrency:
+    group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
+    cancel-in-progress: true
+
+# Configure the release workflow by editing the following values.
+env:
+    # The base filename of the binary produced by `cargo build`.
+    cargo_build_binary_name: phos
+
+    # The path to the assets directory.
+    assets_path: assets
+
+    # Whether to build and package a release for a given target platform.
+    build_for_web: false
+    build_for_linux: true
+    build_for_windows: true
+    build_for_macos: false
+
+    # Whether to upload the packages produced by this workflow to a GitHub release.
+    upload_to_github: true
+
+    # The itch.io project to upload to in the format `user-name/project-name`.
+    # There will be no upload to itch.io if this is commented out.
+    # upload_to_itch: amatsugu/phos
+
+    ############
+    # ADVANCED #
+    ############
+
+    # The ID of the app produced by this workflow.
+    # Applies to macOS releases.
+    # Must contain only A-Z, a-z, 0-9, hyphen, and period: <https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundleidentifier>.
+    app_id: amatsugu.phos
+
+    # The base filename of the binary in the package produced by this workflow.
+    # Applies to Windows, macOS, and Linux releases.
+    # Defaults to `cargo_build_binary_name` if commented out.
+    #app_binary_name: bevy_jam_6
+
+    # The name of the `.zip` or `.dmg` file produced by this workflow.
+    # Defaults to `app_binary_name` if commented out.
+    #app_package_name: bevy-new-2d
+
+    # The display name of the app produced by this workflow.
+    # Applies to macOS releases.
+    # Defaults to `app_package_name` if commented out.
+    app_display_name: phos
+
+    # The short display name of the app produced by this workflow.
+    # Applies to macOS releases.
+    # Must be 15 or fewer characters: <https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundlename>.
+    # Defaults to `app_display_name` if commented out.
+    #app_short_name: Phos
+
+    # Before enabling LFS, please take a look at GitHub's documentation for costs and quota limits:
+    # <https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-storage-and-bandwidth-usage>
+    git_lfs: false
+
+    # Enabling this only helps with consecutive releases to the same tag (and takes up cache storage space).
+    # See: <https://github.com/orgs/community/discussions/27059>.
+    use_github_cache: false
+
+    # Reduce compile time.
+    RUSTFLAGS: -Zshare-generics=y -Zthreads=0
+
+jobs:
+    # Forward some environment variables as outputs of this job.
+    # This is needed because the `env` context can't be used in the `if:` condition of a job:
+    # <https://docs.github.com/en/actions/learn-github-actions/contexts#context-availability>
+    forward-env:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Do nothing
+              run: "true"
+        outputs:
+            upload_to_itch: ${{ env.upload_to_itch }}
+
+    # Determine the version number for this workflow.
+    get-version:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Determine version number
+              id: tag
+              run: echo "tag=${GITHUB_REF#refs/tags/}" >> "${GITHUB_OUTPUT}"
+        outputs:
+            # Use the input from workflow dispatch, or fall back to the git tag.
+            version: ${{ inputs.version || steps.tag.outputs.tag }}
+
+    # Build and package a release for each platform.
+    build:
+        needs:
+            - get-version
+        env:
+            version: ${{ needs.get-version.outputs.version }}
+            # Avoid rate-limiting. See: <https://github.com/cargo-bins/cargo-binstall/issues/2045>.
+            GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        strategy:
+            matrix:
+                include:
+                    - platform: web
+                      targets: wasm32-unknown-unknown
+                      package_ext: .zip
+                      runner: ubuntu-latest
+
+                    - platform: linux
+                      targets: x86_64-unknown-linux-gnu
+                      package_ext: .zip
+                      runner: ubuntu-latest
+
+                    - platform: windows
+                      targets: x86_64-pc-windows-msvc
+                      binary_ext: .exe
+                      package_ext: .zip
+                      runner: windows-latest
+
+                    - platform: macos
+                      targets: x86_64-apple-darwin aarch64-apple-darwin
+                      app_suffix: .app/Contents/MacOS
+                      package_ext: .dmg
+                      runner: macos-latest
+        runs-on: ${{ matrix.runner }}
+        permissions:
+            # Required to create a GitHub release: <https://docs.github.com/en/rest/releases/releases#create-a-release>.
+            contents: write
+        defaults:
+            run:
+                shell: bash
+
+        steps:
+            - name: Set up environment
+              run: |
+                  # Default values:
+                  echo "app_binary_name=${app_binary_name:=${{ env.cargo_build_binary_name }}}" >> "${GITHUB_ENV}"
+                  echo "app_package_name=${app_package_name:=${app_binary_name}}" >> "${GITHUB_ENV}"
+                  echo "app_display_name=${app_display_name:=${app_package_name}}" >> "${GITHUB_ENV}"
+                  echo "app_short_name=${app_short_name:=${app_display_name}}" >> "${GITHUB_ENV}"
+
+                  # File paths:
+                  echo "app=tmp/app/${app_package_name}"'${{ matrix.app_suffix }}' >> "${GITHUB_ENV}"
+                  echo "package=${app_package_name}-"'${{ matrix.platform }}${{ matrix.package_ext }}' >> "${GITHUB_ENV}"
+
+                  # macOS environment:
+                  if [ '${{ matrix.platform }}' = 'macos' ]; then
+                    echo 'MACOSX_DEPLOYMENT_TARGET=11.0' >> "${GITHUB_ENV}" # macOS 11.0 Big Sur is the first version to support universal binaries.
+                    echo "SDKROOT=$(xcrun --sdk macosx --show-sdk-path)" >> "${GITHUB_ENV}"
+                  fi
+
+                  # Check if building for this platform is enabled.
+                  echo 'is_platform_enabled=${{
+                    (matrix.platform == 'web' && env.build_for_web == 'true') ||
+                    (matrix.platform == 'linux' && env.build_for_linux == 'true') ||
+                    (matrix.platform == 'windows' && env.build_for_windows == 'true') ||
+                    (matrix.platform == 'macos' && env.build_for_macos == 'true')
+                  }}' >> "${GITHUB_ENV}"
+
+            - name: Checkout repository
+              if: ${{ env.is_platform_enabled == 'true' }}
+              uses: actions/checkout@v4
+              with:
+                  lfs: ${{ env.git_lfs }}
+
+            - name: Install Rust toolchain
+              if: ${{ env.is_platform_enabled == 'true' }}
+              uses: dtolnay/rust-toolchain@nightly
+              with:
+                  targets: ${{ matrix.targets }}
+
+            - name: Restore Rust cache
+              if: ${{ env.is_platform_enabled == 'true' && env.use_github_cache == 'true' }}
+              uses: Swatinem/rust-cache@v2
+              with:
+                  shared-key: release
+                  save-if: ${{ github.ref == 'refs/heads/main' }}
+
+            - name: Install build dependencies (Linux)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'linux' }}
+              run: sudo apt-get -y update; sudo apt-get -y install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+
+            - name: Prepare output directories
+              if: ${{ env.is_platform_enabled == 'true' }}
+              run: rm -rf tmp; mkdir -p tmp/binary '${{ env.app }}'
+
+            - name: Install cargo-binstall
+              if: ${{ env.is_platform_enabled == 'true' }}
+              uses: cargo-bins/cargo-binstall@main
+
+            - name: Install Bevy CLI
+              if: ${{ env.is_platform_enabled == 'true' }}
+              run: cargo binstall --locked --no-confirm --force --git='https://github.com/TheBevyFlock/bevy_cli' bevy_cli
+
+            - name: Build and add web bundle to app (Web)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'web' }}
+              run: |
+                  cargo binstall --locked --no-confirm --force wasm-bindgen-cli
+                  cargo binstall --locked --no-confirm --force wasm-opt
+                  RUSTFLAGS='-Zshare-generics=y -Zthreads=0 --cfg getrandom_backend="wasm_js"' bevy build --locked --release --features='${{ matrix.features }} web' --yes web --bundle
+                  mv 'target/bevy_web/web-release/${{ env.cargo_build_binary_name }}' '${{ env.app }}'
+
+            - name: Build and add binaries to app (non-Web)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform != 'web' }}
+              run: |
+                  for target in ${{ matrix.targets }}; do
+                    bevy build --locked --release --target="${target}" --features='${{ matrix.features }}'
+                    mv target/"${target}"/release/'${{ env.cargo_build_binary_name }}${{ matrix.binary_ext }}' tmp/binary/"${target}"'${{ matrix.binary_ext }}'
+                  done
+                  if [ '${{ matrix.platform }}' = 'macos' ]; then
+                    lipo tmp/binary/*'${{ matrix.binary_ext }}' -create -output '${{ env.app }}/${{ env.app_binary_name }}${{ matrix.binary_ext }}'
+                  else
+                    mv tmp/binary/*'${{ matrix.binary_ext }}' '${{ env.app }}/${{ env.app_binary_name }}${{ matrix.binary_ext }}'
+                  fi
+
+            - name: Add assets to app (non-Web)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform != 'web' }}
+              run: cp -R ./'${{ env.assets_path }}' '${{ env.app }}' || true # Ignore error if assets folder does not exist.
+
+            - name: Add metadata to app (macOS)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'macos' }}
+              run: |
+                  cat >'${{ env.app }}/../Info.plist' <<EOF
+                    <?xml version="1.0" encoding="UTF-8"?>
+                    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+                    <plist version="1.0">
+                        <dict>
+                            <key>CFBundleDevelopmentRegion</key>
+                            <string>en</string>
+                            <key>CFBundleDisplayName</key>
+                            <string>${{ env.app_display_name }}</string>
+                            <key>CFBundleExecutable</key>
+                            <string>${{ env.app_binary_name }}</string>
+                            <key>CFBundleIdentifier</key>
+                            <string>${{ env.app_id }}</string>
+                            <key>CFBundleName</key>
+                            <string>${{ env.app_short_name }}</string>
+                            <key>CFBundleShortVersionString</key>
+                            <string>${{ env.version }}</string>
+                            <key>CFBundleVersion</key>
+                            <string>${{ env.version }}</string>
+                            <key>CFBundleInfoDictionaryVersion</key>
+                            <string>6.0</string>
+                            <key>CFBundlePackageType</key>
+                            <string>APPL</string>
+                            <key>CFBundleSupportedPlatforms</key>
+                            <array>
+                                <string>MacOSX</string>
+                            </array>
+                        </dict>
+                    </plist>
+                  EOF
+
+            - name: Package app (non-Windows)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform != 'windows' }}
+              working-directory: tmp/app
+              run: |
+                  if [ '${{ matrix.platform }}' = 'macos' ]; then
+                    ln -s /Applications .
+                    hdiutil create -fs HFS+ -volname '${{ env.app_package_name }}' -srcfolder . '${{ env.package }}'
+                  else
+                    zip --recurse-paths '${{ env.package }}' '${{ env.app_package_name }}'
+                  fi
+
+            - name: Package app (Windows)
+              if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'windows' }}
+              working-directory: tmp/app
+              shell: pwsh
+              run: Compress-Archive -Path '${{ env.app_package_name }}' -DestinationPath '${{ env.package }}'
+
+            - name: Upload package to workflow artifacts
+              if: ${{ env.is_platform_enabled == 'true' }}
+              uses: actions/upload-artifact@v4
+              with:
+                  path: tmp/app/${{ env.package }}
+                  name: package-${{ matrix.platform }}
+                  retention-days: 1
+
+            - name: Upload package to GitHub release
+              if: ${{ env.is_platform_enabled == 'true' && env.upload_to_github == 'true' }}
+              uses: svenstaro/upload-release-action@v2
+              with:
+                  repo_token: ${{ secrets.GITHUB_TOKEN }}
+                  file: tmp/app/${{ env.package }}
+                  asset_name: ${{ env.package }}
+                  release_name: ${{ env.version }}
+                  tag: ${{ env.version }}
+                  overwrite: true
+
+    # Upload all packages to itch.io.
+    upload-to-itch:
+        runs-on: ubuntu-latest
+        needs:
+            - forward-env
+            - get-version
+            - build
+        if: ${{ needs.forward-env.outputs.upload_to_itch != '' }}
+
+        steps:
+            - name: Download all packages
+              uses: actions/download-artifact@v4
+              with:
+                  pattern: package-*
+                  path: tmp
+
+            - name: Install butler
+              run: |
+                  curl -L -o butler.zip 'https://broth.itch.zone/butler/linux-amd64/LATEST/archive/default'
+                  unzip butler.zip
+                  chmod +x butler
+                  ./butler -V
+
+            - name: Upload all packages to itch.io
+              env:
+                  BUTLER_API_KEY: ${{ secrets.BUTLER_CREDENTIALS }}
+              run: |
+                  for channel in $(ls tmp); do
+                    ./butler push \
+                      --fix-permissions \
+                      --userversion='${{ needs.get-version.outputs.version }}' \
+                      tmp/"${channel}"/* \
+                      '${{ env.upload_to_itch }}':"${channel#package-}"
+                  done

.github/workflows/release.yaml.template

@@ -0,0 +1,347 @@
+name: Release
+
+on:
+  # Trigger this workflow when a tag is pushed in the format `v1.2.3`.
+  push:
+    tags:
+      # Pattern syntax: <https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet>.
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+  # Trigger this workflow manually via workflow dispatch.
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version number in the format `v1.2.3`"
+        required: true
+        type: string
+
+{% raw -%}
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref || github.run_id }}
+  cancel-in-progress: true
+{%- endraw %}
+
+# Configure the release workflow by editing the following values.
+env:
+  # The base filename of the binary produced by `cargo build`.
+  cargo_build_binary_name: {{project-name}}
+
+  # The path to the assets directory.
+  assets_path: assets
+
+  # Whether to build and package a release for a given target platform.
+  build_for_web: true
+  build_for_linux: true
+  build_for_windows: true
+  build_for_macos: true
+
+  # Whether to upload the packages produced by this workflow to a GitHub release.
+  upload_to_github: true
+
+  # The itch.io project to upload to in the format `user-name/project-name`.
+  # There will be no upload to itch.io if this is commented out.
+  {%- if itch_username != "" %}
+  {%- if itch_project != "" %}
+  upload_to_itch: {{itch_username}}/{{itch_project}}
+  {%- else %}
+  upload_to_itch: {{itch_username}}/{{project-name}}
+  {%- endif %}
+  {%- else %}
+  #upload_to_itch: your-itch-username/{{project-name}}
+  {%- endif %}
+
+  ############
+  # ADVANCED #
+  ############
+
+  # The ID of the app produced by this workflow.
+  # Applies to macOS releases.
+  # Must contain only A-Z, a-z, 0-9, hyphen, and period: <https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundleidentifier>.
+  app_id: {{itch_username | kebab_case}}.{{project-name | kebab_case}}
+
+  # The base filename of the binary in the package produced by this workflow.
+  # Applies to Windows, macOS, and Linux releases.
+  # Defaults to `cargo_build_binary_name` if commented out.
+  #app_binary_name: {{project-name}}
+
+  # The name of the `.zip` or `.dmg` file produced by this workflow.
+  # Defaults to `app_binary_name` if commented out.
+  #app_package_name: {{project-name | kebab_case}}
+
+  # The display name of the app produced by this workflow.
+  # Applies to macOS releases.
+  # Defaults to `app_package_name` if commented out.
+  #app_display_name: {{project-name | title_case}}
+
+  # The short display name of the app produced by this workflow.
+  # Applies to macOS releases.
+  # Must be 15 or fewer characters: <https://developer.apple.com/documentation/bundleresources/information_property_list/cfbundlename>.
+  # Defaults to `app_display_name` if commented out.
+  #app_short_name: {{project-name | title_case | truncate: 15, "…"}}
+
+  # Before enabling LFS, please take a look at GitHub's documentation for costs and quota limits:
+  # <https://docs.github.com/en/repositories/working-with-files/managing-large-files/about-storage-and-bandwidth-usage>
+  git_lfs: false
+
+  # Enabling this only helps with consecutive releases to the same tag (and takes up cache storage space).
+  # See: <https://github.com/orgs/community/discussions/27059>.
+  use_github_cache: false
+
+  # Reduce compile time.
+  RUSTFLAGS: -Dwarnings -Zshare-generics=y -Zthreads=0
+
+{% raw -%}
+jobs:
+  # Forward some environment variables as outputs of this job.
+  # This is needed because the `env` context can't be used in the `if:` condition of a job:
+  # <https://docs.github.com/en/actions/learn-github-actions/contexts#context-availability>
+  forward-env:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Do nothing
+        run: "true"
+    outputs:
+      upload_to_itch: ${{ env.upload_to_itch }}
+
+  # Determine the version number for this workflow.
+  get-version:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Determine version number
+        id: tag
+        run: echo "tag=${GITHUB_REF#refs/tags/}" >> "${GITHUB_OUTPUT}"
+    outputs:
+      # Use the input from workflow dispatch, or fall back to the git tag.
+      version: ${{ inputs.version || steps.tag.outputs.tag }}
+
+  # Build and package a release for each platform.
+  build:
+    needs:
+      - get-version
+    env:
+      version: ${{ needs.get-version.outputs.version }}
+      # Avoid rate-limiting. See: <https://github.com/cargo-bins/cargo-binstall/issues/2045>.
+      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    strategy:
+      matrix:
+        include:
+          - platform: web
+            targets: wasm32-unknown-unknown
+            package_ext: .zip
+            runner: ubuntu-latest
+
+          - platform: linux
+            targets: x86_64-unknown-linux-gnu
+            package_ext: .zip
+            runner: ubuntu-latest
+
+          - platform: windows
+            targets: x86_64-pc-windows-msvc
+            binary_ext: .exe
+            package_ext: .zip
+            runner: windows-latest
+
+          - platform: macos
+            targets: x86_64-apple-darwin aarch64-apple-darwin
+            app_suffix: .app/Contents/MacOS
+            package_ext: .dmg
+            runner: macos-latest
+    runs-on: ${{ matrix.runner }}
+    permissions:
+      # Required to create a GitHub release: <https://docs.github.com/en/rest/releases/releases#create-a-release>.
+      contents: write
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+      - name: Set up environment
+        run: |
+          # Default values:
+          echo "app_binary_name=${app_binary_name:=${{ env.cargo_build_binary_name }}}" >> "${GITHUB_ENV}"
+          echo "app_package_name=${app_package_name:=${app_binary_name}}" >> "${GITHUB_ENV}"
+          echo "app_display_name=${app_display_name:=${app_package_name}}" >> "${GITHUB_ENV}"
+          echo "app_short_name=${app_short_name:=${app_display_name}}" >> "${GITHUB_ENV}"
+
+          # File paths:
+          echo "app=tmp/app/${app_package_name}"'${{ matrix.app_suffix }}' >> "${GITHUB_ENV}"
+          echo "package=${app_package_name}-"'${{ matrix.platform }}${{ matrix.package_ext }}' >> "${GITHUB_ENV}"
+
+          # macOS environment:
+          if [ '${{ matrix.platform }}' = 'macos' ]; then
+            echo 'MACOSX_DEPLOYMENT_TARGET=11.0' >> "${GITHUB_ENV}" # macOS 11.0 Big Sur is the first version to support universal binaries.
+            echo "SDKROOT=$(xcrun --sdk macosx --show-sdk-path)" >> "${GITHUB_ENV}"
+          fi
+
+          # Check if building for this platform is enabled.
+          echo 'is_platform_enabled=${{
+            (matrix.platform == 'web' && env.build_for_web == 'true') ||
+            (matrix.platform == 'linux' && env.build_for_linux == 'true') ||
+            (matrix.platform == 'windows' && env.build_for_windows == 'true') ||
+            (matrix.platform == 'macos' && env.build_for_macos == 'true')
+          }}' >> "${GITHUB_ENV}"
+
+      - name: Checkout repository
+        if: ${{ env.is_platform_enabled == 'true' }}
+        uses: actions/checkout@v4
+        with:
+          lfs: ${{ env.git_lfs }}
+
+      - name: Install Rust toolchain
+        if: ${{ env.is_platform_enabled == 'true' }}
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          targets: ${{ matrix.targets }}
+
+      - name: Restore Rust cache
+        if: ${{ env.is_platform_enabled == 'true' && env.use_github_cache == 'true' }}
+        uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: release
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+
+      - name: Install build dependencies (Linux)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'linux' }}
+        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+
+      - name: Prepare output directories
+        if: ${{ env.is_platform_enabled == 'true' }}
+        run: rm -rf tmp; mkdir -p tmp/binary '${{ env.app }}'
+
+      - name: Install cargo-binstall
+        if: ${{ env.is_platform_enabled == 'true' }}
+        uses: cargo-bins/cargo-binstall@main
+
+      - name: Install Bevy CLI
+        if: ${{ env.is_platform_enabled == 'true' }}
+        run: cargo binstall --locked --no-confirm --force --git='https://github.com/TheBevyFlock/bevy_cli' bevy_cli
+
+      - name: Build and add web bundle to app (Web)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'web' }}
+        run: |
+          cargo binstall --locked --no-confirm --force wasm-bindgen-cli
+          cargo binstall --locked --no-confirm --force wasm-opt
+          bevy build --locked --release --features='${{ matrix.features }}' --yes web --bundle
+          mv 'target/bevy_web/web-release/${{ env.cargo_build_binary_name }}' '${{ env.app }}'
+
+      - name: Build and add binaries to app (non-Web)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform != 'web' }}
+        run: |
+          for target in ${{ matrix.targets }}; do
+            bevy build --locked --release --target="${target}" --features='${{ matrix.features }}'
+            mv target/"${target}"/release/'${{ env.cargo_build_binary_name }}${{ matrix.binary_ext }}' tmp/binary/"${target}"'${{ matrix.binary_ext }}'
+          done
+          if [ '${{ matrix.platform }}' = 'macos' ]; then
+            lipo tmp/binary/*'${{ matrix.binary_ext }}' -create -output '${{ env.app }}/${{ env.app_binary_name }}${{ matrix.binary_ext }}'
+          else
+            mv tmp/binary/*'${{ matrix.binary_ext }}' '${{ env.app }}/${{ env.app_binary_name }}${{ matrix.binary_ext }}'
+          fi
+
+      - name: Add assets to app (non-Web)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform != 'web' }}
+        run: cp -R ./'${{ env.assets_path }}' '${{ env.app }}' || true # Ignore error if assets folder does not exist.
+
+      - name: Add metadata to app (macOS)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'macos' }}
+        run: |
+          cat >'${{ env.app }}/../Info.plist' <<EOF
+            <?xml version="1.0" encoding="UTF-8"?>
+            <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+            <plist version="1.0">
+                <dict>
+                    <key>CFBundleDevelopmentRegion</key>
+                    <string>en</string>
+                    <key>CFBundleDisplayName</key>
+                    <string>${{ env.app_display_name }}</string>
+                    <key>CFBundleExecutable</key>
+                    <string>${{ env.app_binary_name }}</string>
+                    <key>CFBundleIdentifier</key>
+                    <string>${{ env.app_id }}</string>
+                    <key>CFBundleName</key>
+                    <string>${{ env.app_short_name }}</string>
+                    <key>CFBundleShortVersionString</key>
+                    <string>${{ env.version }}</string>
+                    <key>CFBundleVersion</key>
+                    <string>${{ env.version }}</string>
+                    <key>CFBundleInfoDictionaryVersion</key>
+                    <string>6.0</string>
+                    <key>CFBundlePackageType</key>
+                    <string>APPL</string>
+                    <key>CFBundleSupportedPlatforms</key>
+                    <array>
+                        <string>MacOSX</string>
+                    </array>
+                </dict>
+            </plist>
+          EOF
+
+      - name: Package app (non-Windows)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform != 'windows' }}
+        working-directory: tmp/app
+        run: |
+          if [ '${{ matrix.platform }}' = 'macos' ]; then
+            ln -s /Applications .
+            hdiutil create -fs HFS+ -volname '${{ env.app_package_name }}' -srcfolder . '${{ env.package }}'
+          else
+            zip --recurse-paths '${{ env.package }}' '${{ env.app_package_name }}'
+          fi
+
+      - name: Package app (Windows)
+        if: ${{ env.is_platform_enabled == 'true' && matrix.platform == 'windows' }}
+        working-directory: tmp/app
+        shell: pwsh
+        run: Compress-Archive -Path '${{ env.app_package_name }}' -DestinationPath '${{ env.package }}'
+
+      - name: Upload package to workflow artifacts
+        if: ${{ env.is_platform_enabled == 'true' }}
+        uses: actions/upload-artifact@v4
+        with:
+          path: tmp/app/${{ env.package }}
+          name: package-${{ matrix.platform }}
+          retention-days: 1
+
+      - name: Upload package to GitHub release
+        if: ${{ env.is_platform_enabled == 'true' && env.upload_to_github == 'true' }}
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: tmp/app/${{ env.package }}
+          asset_name: ${{ env.package }}
+          release_name: ${{ env.version }}
+          tag: ${{ env.version }}
+          overwrite: true
+
+  # Upload all packages to itch.io.
+  upload-to-itch:
+    runs-on: ubuntu-latest
+    needs:
+      - forward-env
+      - get-version
+      - build
+    if: ${{ needs.forward-env.outputs.upload_to_itch != '' }}
+
+    steps:
+      - name: Download all packages
+        uses: actions/download-artifact@v4
+        with:
+          pattern: package-*
+          path: tmp
+
+      - name: Install butler
+        run: |
+          curl -L -o butler.zip 'https://broth.itch.zone/butler/linux-amd64/LATEST/archive/default'
+          unzip butler.zip
+          chmod +x butler
+          ./butler -V
+
+      - name: Upload all packages to itch.io
+        env:
+          BUTLER_API_KEY: ${{ secrets.BUTLER_CREDENTIALS }}
+        run: |
+          for channel in $(ls tmp); do
+            ./butler push \
+              --fix-permissions \
+              --userversion='${{ needs.get-version.outputs.version }}' \
+              tmp/"${channel}"/* \
+              '${{ env.upload_to_itch }}':"${channel#package-}"
+          done
+{%- endraw %}

.github/workflows/rust.yml

@@ -1,24 +0,0 @@
-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: Install deps
-      run: sudo apt install libasound2-dev libudev-dev
-    - name: Build
-      run: cargo build
-    - name: Run tests
-      run: cargo test

Cargo.toml

@@ -2,10 +2,15 @@
 resolver = "2"
 members = [
     "game/main",
-	"game/buildings",
 	"game/shared",
+	"game/buildings",
+	"game/units",
+	"game/resources",
     "engine/world_generation",
-	"engine/asset_loader", "game/buildings", "game/shared", "game/units", "engine/data", "game/resources", "engine/asset_loader_proc"]
+	"engine/asset_loader",
+	"engine/data",
+	"engine/hex",
+]
 
 # Enable a small amount of optimization in debug mode
 [profile.dev]

README.md

@@ -1,3 +1,5 @@
 # Phos
 
-You play as a robot colonizer that has been sent out to an alien planet with one goal. Harvest its resources and send them back home. To accomplish this you must build a base on the planet. As your base develops you will be able to build more advanced structures to harvest at an increased scale. And eventually you will be able to accomplish your goal of sending resources back to your mother planet. But your invasion wont go unchallenged. The native inhabitants of the planet won’t sit idly by as you strip their world of its resources.
+You play as a robot colonizer that has been sent out to an alien planet with one goal. Harvest its resources and send them back home. To accomplish this you must build a base on the planet. As your base develops you will be able to build more advanced structures to harvest at an increased scale. And eventually you will be able to accomplish your goal of sending resources back to your mother planet. But your invasion wont go unchallenged. The native inhabitants of the planet won’t sit idly by as you strip their world of its resources.
+
+![development screenshot](https://aoba.app/m/69bafe2f7c042ee871b94dcf)

engine/asset_loader/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = "1.0.204"
+serde = "1.0.228"
-serde_json = "1.0.120"
+serde_json = "1.0.149"
-bevy = "0.15.1"
+bevy = "0.18.0"
-ron = "0.8.1"
+ron = "0.12.0"

engine/asset_loader/src/macros.rs

@@ -9,8 +9,7 @@ macro_rules! create_asset_loader {
 		$($string_array_name: ident -> $handle_array_name: ident)* ?
 	) => {
 		use bevy::prelude::*;
-		use bevy::asset::{AssetLoader, AssetEvent, AssetEvents, LoadContext, LoadState, AsyncReadExt, io::Reader};
+		use bevy::asset::{AssetLoader, AssetEvent,  LoadContext, LoadState, AsyncReadExt, io::Reader};
-		use bevy::utils::BoxedFuture;
 		pub struct $plugin_name;
 		impl Plugin for $plugin_name {
 			fn build(&self, app: &mut App) {
@@ -19,7 +18,7 @@ macro_rules! create_asset_loader {
 			}
 		}
 
-		#[derive(Default)]
+		#[derive(Default, TypePath)]
 		pub struct $loader_name;
 
 		impl AssetLoader for $loader_name {
@@ -31,10 +30,10 @@ macro_rules! create_asset_loader {
 
 			async fn load(
 		        &self,
-				reader: & mut dyn bevy::asset::io::Reader,
+		        reader: &mut dyn bevy::asset::io::Reader,
-				_: &Self::Settings,
+		        settings: &Self::Settings,
-				load_context: &mut LoadContext<'_>,
+		        load_context: &mut bevy::asset::LoadContext<'_>,
-		    ) -> Result<Self::Asset, Self::Error> {
+		    ) -> Result<Self::Asset, Self::Error>{
 				let mut bytes = Vec::new();
 				let read_result = reader.read_to_end(&mut bytes).await;
 				if read_result.is_err() {

engine/asset_loader_proc/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "asset_loader_proc"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-proc-macro = true
-
-[dependencies]
-serde = "1.0.204"
-serde_json = "1.0.120"
-bevy = "0.15.1"
-ron = "0.8.1"

engine/asset_loader_proc/src/lib.rs

@@ -1 +0,0 @@
-  

engine/hex/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "hex"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+bevy = "0.18.1"
+serde = { version = "1.0.228", features = ["derive"] }

engine/hex/src/chunk.rs

@@ -1,9 +1,9 @@
-use crate::hex_utils::SHORT_DIAGONAL;
+use crate::SHORT_DIAGONAL;
 use bevy::prelude::*;
 
-
 #[derive(Clone)]
-pub struct Chunk {
+pub struct Chunk
+{
 	pub heights: [f32; Chunk::AREA],
 	pub textures: [[u32; 2]; Chunk::AREA],
 	// pub biome_data: [BiomeData; Chunk::AREA],
@@ -13,8 +13,10 @@ pub struct Chunk {
 	pub max_level: f32,
 }
 
-impl Default for Chunk {
+impl Default for Chunk
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self {
 			heights: [0.; Chunk::AREA],
 			textures: [[0; 2]; Chunk::AREA],
@@ -27,17 +29,20 @@ impl Default for Chunk {
 	}
 }
 
-impl Chunk {
+impl Chunk
+{
 	pub const SIZE: usize = 64;
 	pub const AREA: usize = Chunk::SIZE * Chunk::SIZE;
 	pub const WORLD_WIDTH: f32 = Chunk::SIZE as f32 * SHORT_DIAGONAL;
 	pub const WORLD_HEIGHT: f32 = Chunk::SIZE as f32 * 1.5;
 	pub const WORLD_SIZE: Vec2 = Vec2::new(Chunk::WORLD_WIDTH, Chunk::WORLD_HEIGHT);
 
-	pub fn get_pos_z_edge(&self) -> [f32; Chunk::SIZE] {
+	pub fn get_pos_z_edge(&self) -> [f32; Chunk::SIZE]
+	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for x in 0..Chunk::SIZE {
+		for x in 0..Chunk::SIZE
+		{
 			let idx = x + (Chunk::SIZE - 1) * Chunk::SIZE;
 			data[x] = self.heights[idx];
 		}
@@ -45,20 +50,24 @@ impl Chunk {
 		return data;
 	}
 
-	pub fn get_neg_z_edge(&self) -> [f32; Chunk::SIZE] {
+	pub fn get_neg_z_edge(&self) -> [f32; Chunk::SIZE]
+	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for x in 0..Chunk::SIZE {
+		for x in 0..Chunk::SIZE
+		{
 			data[x] = self.heights[x];
 		}
 
 		return data;
 	}
 
-	pub fn get_pos_x_edge(&self) -> [f32; Chunk::SIZE] {
+	pub fn get_pos_x_edge(&self) -> [f32; Chunk::SIZE]
+	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for z in 0..Chunk::SIZE {
+		for z in 0..Chunk::SIZE
+		{
 			let idx = (Chunk::SIZE - 1) + z * Chunk::SIZE;
 			data[z] = self.heights[idx];
 		}
@@ -66,10 +75,12 @@ impl Chunk {
 		return data;
 	}
 
-	pub fn get_neg_x_edge(&self) -> [f32; Chunk::SIZE] {
+	pub fn get_neg_x_edge(&self) -> [f32; Chunk::SIZE]
+	{
 		let mut data = [0.; Chunk::SIZE];
 
-		for z in 0..Chunk::SIZE {
+		for z in 0..Chunk::SIZE
+		{
 			let idx = z * Chunk::SIZE;
 			data[z] = self.heights[idx];
 		}

engine/hex/src/hex_coord.rs

@@ -1,27 +1,25 @@
 use std::fmt::Display;
 
-use crate::prelude::Chunk;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 
-pub const OUTER_RADIUS: f32 = 1.;
+use crate::{INNER_RADIUS, OUTER_RADIUS, chunk::Chunk};
-pub const INNER_RADIUS: f32 = OUTER_RADIUS * (SQRT_3 / 2.);
-pub const SHORT_DIAGONAL: f32 = 1. * SQRT_3;
-pub const LONG_DIAGONAL: f32 = 2. * OUTER_RADIUS;
-const SQRT_3: f32 = 1.7320508076;
 
-pub fn offset3d_to_world(offset: Vec3) -> Vec3 {
+pub fn offset3d_to_world(offset: Vec3) -> Vec3
+{
 	let x = (offset.x + (offset.z * 0.5) - (offset.z / 2.).floor()) * (INNER_RADIUS * 2.);
 	return Vec3::new(x, offset.y, offset.z * OUTER_RADIUS * 1.5);
 }
 
-pub fn offset_to_world(offset: IVec2, height: f32) -> Vec3 {
+pub fn offset_to_world(offset: IVec2, height: f32) -> Vec3
+{
 	let off = offset.as_vec2();
 	let x = (off.x + (off.y * 0.5) - (off.y / 2.).floor()) * (INNER_RADIUS * 2.);
 	return Vec3::new(x, height, off.y * OUTER_RADIUS * 1.5);
 }
 
-pub fn offset_to_hex(offset: IVec2) -> IVec3 {
+pub fn offset_to_hex(offset: IVec2) -> IVec3
+{
 	let mut v = IVec3 {
 		x: offset.x - (offset.y / 2),
 		y: offset.y,
@@ -31,15 +29,18 @@ pub fn offset_to_hex(offset: IVec2) -> IVec3 {
 	return v;
 }
 
-pub fn offset_to_index(offset: IVec2, width: usize) -> usize {
+pub fn offset_to_index(offset: IVec2, width: usize) -> usize
+{
 	return offset.x as usize + offset.y as usize * width;
 }
 
-pub fn snap_to_hex_grid(world_pos: Vec3) -> Vec3 {
+pub fn snap_to_hex_grid(world_pos: Vec3) -> Vec3
+{
 	return offset_to_world(world_to_offset_pos(world_pos), world_pos.y);
 }
 
-pub fn world_to_offset_pos(world_pos: Vec3) -> IVec2 {
+pub fn world_to_offset_pos(world_pos: Vec3) -> IVec2
+{
 	let offset = world_pos.z / (OUTER_RADIUS * 3.);
 	let x = (world_pos.x / (INNER_RADIUS * 2.)) - offset;
 	let z = -world_pos.x - offset;
@@ -51,26 +52,32 @@ pub fn world_to_offset_pos(world_pos: Vec3) -> IVec2 {
 	return IVec2::new(ox, oz);
 }
 
-pub fn tile_to_world_distance(dist: u32) -> f32 {
+pub fn tile_to_world_distance(dist: u32) -> f32
+{
 	return dist as f32 * (2. * INNER_RADIUS);
 }
 
-pub fn get_tile_count_in_range(radius: usize) -> usize {
+pub fn get_tile_count_in_range(radius: usize) -> usize
+{
 	return 1 + 3 * (radius + 1) * radius;
 }
 
 #[derive(Default, Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize, Hash)]
-pub struct HexCoord {
+pub struct HexCoord
+{
 	pub hex: IVec3,
 }
 
-impl Display for HexCoord {
+impl Display for HexCoord
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
+	{
 		f.write_fmt(format_args!("HexCoord{}", self.hex))
 	}
 }
 
-impl HexCoord {
+impl HexCoord
+{
 	pub const DIRECTIONS: [IVec3; 6] = [
 		IVec3::new(0, 1, -1),
 		IVec3::new(1, 0, -1),
@@ -82,27 +89,33 @@ impl HexCoord {
 
 	pub const ZERO: HexCoord = HexCoord { hex: IVec3::ZERO };
 
-	pub fn new(x: i32, z: i32) -> Self {
+	pub fn new(x: i32, z: i32) -> Self
+	{
 		return HexCoord {
 			hex: IVec3::new(x, z, -x - z),
 		};
 	}
 
-	pub fn from_hex(hex: IVec2) -> Self {
+	pub fn from_axial(hex: IVec2) -> Self
+	{
 		return HexCoord {
 			hex: IVec3::new(hex.x, hex.y, -hex.x - hex.y),
 		};
 	}
-	pub fn from_grid_pos(x: usize, z: usize) -> Self {
+
+	pub fn from_offset_pos(x: usize, z: usize) -> Self
+	{
 		return HexCoord::new(x as i32 - (z as i32 / 2), z as i32);
 	}
-	pub fn from_offset(offset_pos: IVec2) -> Self {
+	pub fn from_offset(offset_pos: IVec2) -> Self
+	{
 		return HexCoord {
 			hex: offset_to_hex(offset_pos),
 		};
 	}
 
-	pub fn from_world_pos(world_pos: Vec3) -> Self {
+	pub fn from_world_pos(world_pos: Vec3) -> Self
+	{
 		let offset = world_pos.z / (OUTER_RADIUS * 3.);
 		let mut x = world_pos.x / (INNER_RADIUS * 2.);
 		let mut z = -x;
@@ -116,26 +129,31 @@ impl HexCoord {
 		return Self::from_offset(offset_pos);
 	}
 
-	pub fn is_in_bounds(&self, map_height: usize, map_width: usize) -> bool {
+	pub fn is_in_bounds(&self, map_height: usize, map_width: usize) -> bool
+	{
 		let off = self.to_offset();
-		if off.x < 0 || off.y < 0 {
+		if off.x < 0 || off.y < 0
+		{
 			return false;
 		}
 
-		if off.x >= map_width as i32 || off.y >= map_height as i32 {
+		if off.x >= map_width as i32 || off.y >= map_height as i32
+		{
 			return false;
 		}
 
 		return true;
 	}
 
-	pub fn is_on_chunk_edge(&self) -> bool {
+	pub fn is_on_chunk_edge(&self) -> bool
+	{
 		let offset = self.to_offset().rem_euclid(IVec2::splat(Chunk::SIZE as i32));
 		let e = (Chunk::SIZE - 1) as i32;
 		return offset.x == 0 || offset.y == 0 || offset.x == e || offset.y == e;
 	}
 
-	pub fn to_chunk_pos(&self) -> IVec2 {
+	pub fn to_chunk_pos(&self) -> IVec2
+	{
 		let off = self.to_offset();
 
 		return IVec2 {
@@ -145,7 +163,8 @@ impl HexCoord {
 	}
 
 	/// Converts this coordinate to it's chunk local equivalent
-	pub fn to_chunk(&self) -> HexCoord {
+	pub fn to_chunk(&self) -> HexCoord
+	{
 		let c_pos = self.to_chunk_pos();
 		let off = self.to_offset();
 		return HexCoord::from_offset(
@@ -157,76 +176,94 @@ impl HexCoord {
 		);
 	}
 
-	pub fn to_world(&self, height: f32) -> Vec3 {
+	pub fn to_world(&self, height: f32) -> Vec3
+	{
 		return offset_to_world(self.to_offset(), height);
 	}
 
-	pub fn to_offset(&self) -> IVec2 {
+	pub fn to_offset(&self) -> IVec2
+	{
 		return IVec2::new(self.hex.x + (self.hex.y / 2), self.hex.y);
 	}
 
 	/// Convert the current coordiante to an index
-	pub fn to_index(&self, width: usize) -> usize {
+	pub fn to_index(&self, width: usize) -> usize
+	{
 		return ((self.hex.x + self.hex.y * width as i32) + (self.hex.y / 2)) as usize;
 	}
 
 	/// Gets the index of this coord in the chunk array.
 	///
 	/// [`width`] is in number of chunks
-	pub fn to_chunk_index(&self, width: usize) -> usize {
+	pub fn to_chunk_index(&self, width: usize) -> usize
+	{
 		let pos = self.to_chunk_pos();
 		return (pos.x + pos.y * width as i32) as usize;
 	}
 
 	/// Gets the index of this tile in the chunk
-	pub fn to_chunk_local_index(&self) -> usize {
+	pub fn to_chunk_local_index(&self) -> usize
+	{
 		return self.to_chunk().to_index(Chunk::SIZE);
 	}
 
-	pub fn distance(&self, other: &HexCoord) -> i32 {
+	pub fn distance(&self, other: &HexCoord) -> i32
+	{
 		return (self.hex.x - other.hex.x).abs() + (self.hex.y - other.hex.y).abs() + (self.hex.z - other.hex.z).abs();
 	}
 
-	pub fn rotate_around(&self, center: &HexCoord, angle: i32) -> HexCoord {
+	pub fn rotate_around(&self, center: &HexCoord, angle: i32) -> HexCoord
-		if self == center || angle == 0 {
+	{
+		if self == center || angle == 0
+		{
 			return self.clone();
 		}
 
 		let mut a = angle % 6;
 		let mut pc = self.hex - center.hex;
 
-		if a > 0 {
+		if a > 0
-			for _ in 0..a {
+		{
+			for _ in 0..a
+			{
 				pc = Self::slide_right(pc);
 			}
-		} else {
+		}
+		else
+		{
 			a = a.abs();
-			for _ in 0..a {
+			for _ in 0..a
+			{
 				pc = Self::slide_left(pc);
 			}
 		}
-		return HexCoord::from_hex(pc.xy() + center.hex.xy());
+		return HexCoord::from_axial(pc.xy() + center.hex.xy());
 	}
 
-	fn slide_left(hex: IVec3) -> IVec3 {
+	fn slide_left(hex: IVec3) -> IVec3
+	{
 		return (hex * -1).yzx();
 	}
 
-	fn slide_right(hex: IVec3) -> IVec3 {
+	fn slide_right(hex: IVec3) -> IVec3
+	{
 		return (hex * -1).zxy();
 	}
 
-	pub fn scale(&self, dir: i32, radius: usize) -> HexCoord {
+	pub fn scale(&self, dir: usize, radius: usize) -> HexCoord
-		let s = Self::DIRECTIONS[(dir % 6) as usize] * radius as i32;
+	{
-		return Self::from_hex(self.hex.xy() + s.xy());
+		let s = Self::DIRECTIONS[dir % 6] * radius as i32;
+		return Self::from_axial(self.hex.xy() + s.xy());
 	}
 
-	pub fn get_neighbor(&self, dir: usize) -> HexCoord {
+	pub fn get_neighbor(&self, dir: usize) -> HexCoord
+	{
 		let d = Self::DIRECTIONS[dir % 6];
-		return Self::from_hex(self.hex.xy() + d.xy());
+		return Self::from_axial(self.hex.xy() + d.xy());
 	}
 
-	pub fn get_neighbors(&self) -> [HexCoord; 6] {
+	pub fn get_neighbors(&self) -> [HexCoord; 6]
+	{
 		return [
 			self.get_neighbor(0),
 			self.get_neighbor(1),
@@ -237,18 +274,23 @@ impl HexCoord {
 		];
 	}
 
-	pub fn hex_select(&self, radius: usize, include_center: bool) -> Vec<HexCoord> {
+	pub fn hex_select(&self, radius: usize, include_center: bool) -> Vec<HexCoord>
+	{
 		assert!(radius != 0, "Radius cannot be zero");
 		let mut result = Vec::with_capacity(get_tile_count_in_range(radius));
 
-		if include_center {
+		if include_center
+		{
 			result.push(*self);
 		}
 
-		for k in 0..(radius + 1) {
+		for k in 0..(radius + 1)
+		{
 			let mut p = self.scale(4, k);
-			for i in 0..6 {
+			for i in 0..6
-				for _j in 0..k {
+			{
+				for _j in 0..k
+				{
 					p = p.get_neighbor(i);
 					result.push(p);
 				}
@@ -258,28 +300,30 @@ impl HexCoord {
 		return result;
 	}
 
-	pub fn hex_select_bounded(
+	pub fn hex_select_bounded(&self, radius: usize, include_center: bool, height: usize, width: usize)
-		&self,
+	-> Vec<HexCoord>
-		radius: usize,
+	{
-		include_center: bool,
-		height: usize,
-		width: usize,
-	) -> Vec<HexCoord> {
 		assert!(radius != 0, "Radius cannot be zero");
 		let mut result = Vec::with_capacity(get_tile_count_in_range(radius));
 
-		if include_center {
+		if include_center
-			if self.is_in_bounds(height, width) {
+		{
+			if self.is_in_bounds(height, width)
+			{
 				result.push(*self);
 			}
 		}
 
-		for k in 0..(radius + 1) {
+		for k in 0..(radius + 1)
+		{
 			let mut p = self.scale(4, k);
-			for i in 0..6 {
+			for i in 0..6
-				for _j in 0..k {
+			{
+				for _j in 0..k
+				{
 					p = p.get_neighbor(i);
-					if p.is_in_bounds(height, width) {
+					if p.is_in_bounds(height, width)
+					{
 						result.push(p);
 					}
 				}
@@ -289,7 +333,8 @@ impl HexCoord {
 		return result;
 	}
 
-	pub fn select_ring(&self, radius: usize) -> Vec<HexCoord> {
+	pub fn select_ring(&self, radius: usize) -> Vec<HexCoord>
+	{
 		assert!(radius != 0, "Radius cannot be zero");
 		let mut result = Vec::with_capacity(radius * 6);
 
@@ -300,8 +345,10 @@ impl HexCoord {
 		// 	return result;
 		// }
 
-		for i in 0..6 {
+		for i in 0..6
-			for _j in 0..radius {
+		{
+			for _j in 0..radius
+			{
 				result.push(p);
 				p = p.get_neighbor(i);
 			}

engine/hex/src/lib.rs

@@ -0,0 +1,17 @@
+mod chunk;
+mod hex_coord;
+pub mod prelude
+{
+	pub use crate::chunk::*;
+	pub use crate::hex_coord::*;
+	pub use crate::*;
+}
+
+pub const OUTER_RADIUS: f32 = 1.;
+pub const INNER_RADIUS: f32 = OUTER_RADIUS * (SQRT_3 / 2.);
+pub const SHORT_DIAGONAL: f32 = 1. * SQRT_3;
+pub const LONG_DIAGONAL: f32 = 2. * OUTER_RADIUS;
+pub const SQRT_3: f32 = 1.7320508076;
+
+#[cfg(test)]
+mod tests;

engine/hex/src/tests.rs

@@ -0,0 +1,11 @@
+use super::prelude::*;
+
+#[test]
+fn create_coord()
+{
+	let center = HexCoord::from_offset_pos(3, 3);
+	for dir in 0..6
+	{
+		assert_eq!(center.get_neighbor(dir).get_neighbor(dir), center.scale(dir, 2));
+	}
+}

engine/world_generation/Cargo.toml

@@ -6,20 +6,21 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.15.1"
+bevy = "0.18.0"
 noise = "0.9.0"
-serde = { version = "1.0.203", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
-serde_json = "1.0.115"
+serde_json = "1.0.149"
 asset_loader = { path = "../asset_loader" }
-rayon = "1.10.0"
+rayon = "1.11.0"
-bevy-inspector-egui = "0.28.1"
+bevy-inspector-egui = "0.36.0"
-bevy_asset_loader = { version = "0.22.0", features = [
+bevy_asset_loader = { version = "0.25.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
-ron = "0.8.1"
+ron = "0.12.0"
-image = "0.25.2"
+image = "0.25.9"
 num = "0.4.3"
+hex = { path = "../hex" }
 
 [features]
 tracing = ["bevy/trace_tracy"]

engine/world_generation/src/consts.rs

@@ -1,9 +1,7 @@
-use bevy::{
+use bevy::{mesh::MeshVertexAttribute, prelude::*, render::render_resource::VertexFormat};
-	prelude::*,
+use hex::{INNER_RADIUS, OUTER_RADIUS};
-	render::{mesh::MeshVertexAttribute, render_resource::VertexFormat},
-};
 
-use crate::hex_utils::{INNER_RADIUS, OUTER_RADIUS};
+// use crate::hex_utils::{INNER_RADIUS, OUTER_RADIUS};
 
 pub const TEX_MULTI: Vec2 = Vec2::new(1000., 1.);
 

engine/world_generation/src/generators/chunk_colliders.rs

@@ -1,20 +1,24 @@
-use crate::{hex_utils::*, prelude::*};
+use crate::prelude::*;
 #[cfg(feature = "tracing")]
 use bevy::log::*;
 use bevy::prelude::*;
+use hex::prelude::*;
 
 const CHUNK_TOTAL: usize = Chunk::SIZE * Chunk::SIZE;
 
-pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3]>)
+{
 	#[cfg(feature = "tracing")]
 	let span = info_span!("generate_chunk_collider").entered();
 	let vertex_count: usize = CHUNK_TOTAL * 6;
 	let mut verts = Vec::with_capacity(vertex_count);
 	let mut indices = Vec::with_capacity(vertex_count);
-	for z in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
-		for x in 0..Chunk::SIZE {
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let height = chunk.heights[x + z * Chunk::SIZE];
-			let coord = HexCoord::from_grid_pos(x, z);
+			let coord = HexCoord::from_offset_pos(x, z);
 			let neighbors = chunk.get_neighbors(&coord);
 			let off_pos = Vec3::new(x as f32, height, z as f32);
 			let tile_pos = offset3d_to_world(off_pos);
@@ -24,9 +28,11 @@ pub fn generate_chunk_collider(chunk: &MeshChunkData) -> (Vec<Vec3>, Vec<[u32; 3
 	return (verts, indices);
 }
 
-fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>, neighbors: &[f32; 6]) {
+fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>, neighbors: &[f32; 6])
+{
 	let idx = verts.len() as u32;
-	for i in 0..6 {
+	for i in 0..6
+	{
 		let p = pos + HEX_CORNERS[i];
 		verts.push(p);
 	}
@@ -37,9 +43,11 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 	indices.push([idx + 2, idx + 4, idx + 5]);
 	indices.push([idx + 2, idx + 3, idx + 4]);
 
-	for i in 0..neighbors.len() {
+	for i in 0..neighbors.len()
+	{
 		let n_height = neighbors[i];
-		if n_height < pos.y {
+		if n_height < pos.y
+		{
 			create_tile_wall_collider(
 				idx,
 				Vec3::new(pos.x, n_height.min(pos.y - OUTER_RADIUS / 2.), pos.z),
@@ -51,7 +59,8 @@ fn create_tile_collider(pos: Vec3, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32
 	}
 }
 
-fn create_tile_wall_collider(idx: u32, pos: Vec3, dir: usize, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>) {
+fn create_tile_wall_collider(idx: u32, pos: Vec3, dir: usize, verts: &mut Vec<Vec3>, indices: &mut Vec<[u32; 3]>)
+{
 	let idx2 = verts.len() as u32;
 
 	verts.push(pos + HEX_CORNERS[(dir) % 6]);

engine/world_generation/src/generators/mesh_generator.rs

@@ -1,16 +1,13 @@
-use crate::hex_utils::HexCoord;
+use crate::prelude::*;
-use crate::{hex_utils::offset3d_to_world, prelude::*};
+use bevy::asset::RenderAssetUsages;
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{
+use bevy::mesh::{Indices, PrimitiveTopology};
-	prelude::*,
+use bevy::prelude::*;
-	render::{
+use hex::prelude::*;
-		mesh::{Indices, PrimitiveTopology},
-		render_asset::RenderAssetUsages,
-	},
-};
 
-pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
+pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh
+{
 	#[cfg(feature = "tracing")]
 	let span = info_span!("generate_chunk_mesh").entered();
 
@@ -20,13 +17,15 @@ pub fn generate_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
 	let mut indices = Vec::with_capacity(vertex_count);
 	let mut normals = Vec::with_capacity(vertex_count);
 
-	for z in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
-		for x in 0..Chunk::SIZE {
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let idx = x + z * Chunk::SIZE;
 			let height = chunk.heights[idx];
 			let off_pos = Vec3::new(x as f32, height, z as f32);
 			let tile_pos = offset3d_to_world(off_pos);
-			let coord = HexCoord::from_grid_pos(x, z);
+			let coord = HexCoord::from_offset_pos(x, z);
 			let n = chunk.get_neighbors(&coord);
 
 			create_tile(
@@ -63,20 +62,23 @@ fn create_tile(
 	normals: &mut Vec<Vec3>,
 	texture_index: u32,
 	side_texture_index: u32,
-) {
+)
+{
 	let uv_offset = Vec2::splat(0.5);
 	let tex_off = Vec2::new(texture_index as f32, 0.);
 	let side_tex_off = Vec2::new(side_texture_index as f32, 0.);
 
 	let idx = verts.len() as u32;
-	for i in 0..6 {
+	for i in 0..6
+	{
 		let p = pos + HEX_CORNERS[i];
 		verts.push(p);
 		let uv = (HEX_CORNERS[i].xz() / 2.) + uv_offset;
 		uvs.push((uv / TEX_MULTI) + tex_off);
 		normals.push(Vec3::Y);
 	}
-	for i in 0..3 {
+	for i in 0..3
+	{
 		let off = i * 2;
 		indices.push(off + idx);
 		indices.push(((off + 1) % 6) + idx);
@@ -86,15 +88,19 @@ fn create_tile(
 	indices.push(idx + 2);
 	indices.push(idx + 4);
 
-	for i in 0..neighbors.len() {
+	for i in 0..neighbors.len()
+	{
 		let n_height = neighbors[i];
-		if n_height < pos.y {
+		if n_height < pos.y
+		{
 			create_tile_wall(pos, i, n_height, verts, uvs, indices, normals, side_tex_off);
 		}
 	}
 }
 
-pub fn generate_chunk_water_mesh(chunk: &MeshChunkData, sealevel: f32, map_width: usize, map_height: usize) -> Mesh {
+#[allow(unused)]
+pub fn generate_chunk_water_mesh(chunk: &MeshChunkData, sealevel: f32, map_width: usize, map_height: usize) -> Mesh
+{
 	#[cfg(feature = "tracing")]
 	let _gen_mesh = info_span!("Generate Water Surface Mesh").entered();
 	let vertex_count: usize = Chunk::SIZE * Chunk::SIZE * 7;
@@ -103,16 +109,19 @@ pub fn generate_chunk_water_mesh(chunk: &MeshChunkData, sealevel: f32, map_width
 	let mut indices = Vec::with_capacity(vertex_count);
 	let mut normals = Vec::with_capacity(vertex_count);
 
-	for z in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
-		for x in 0..Chunk::SIZE {
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let idx = x + z * Chunk::SIZE;
 			let height = chunk.heights[idx];
-			if height > sealevel {
+			if height > sealevel
+			{
 				continue;
 			}
 			let off_pos = Vec3::new(x as f32, sealevel, z as f32);
 			let tile_pos = offset3d_to_world(off_pos);
-			let coord = HexCoord::from_grid_pos(x, z);
+			let coord = HexCoord::from_offset_pos(x, z);
 			let (n, neighbor_has_land) = chunk.get_neighbors_with_water_info(&coord);
 
 			create_tile_water_surface(
@@ -147,8 +156,10 @@ fn create_tile_water_surface(
 	uvs: &mut Vec<Vec2>,
 	indices: &mut Vec<u32>,
 	normals: &mut Vec<Vec3>,
-) {
+)
-	if !neighbor_has_land {
+{
+	if !neighbor_has_land
+	{
 		crate_tile_water_inner_surface(pos, dist_to_land, neighbors, verts, uvs, indices, normals);
 		return;
 	}
@@ -163,23 +174,29 @@ fn crate_tile_water_inner_surface(
 	uvs: &mut Vec<Vec2>,
 	indices: &mut Vec<u32>,
 	normals: &mut Vec<Vec3>,
-) {
+)
+{
 	//todo: share verts
 	let idx = verts.len() as u32;
-	for i in 0..6 {
+	for i in 0..6
+	{
 		let p = pos + HEX_CORNERS[i];
 		verts.push(p);
 		let n1 = if let Some(v) = neighbors[i].1 { v } else { dist_to_land };
-		let n2 = if let Some(v) = neighbors[(i + 5) % 6].1 {
+		let n2 = if let Some(v) = neighbors[(i + 5) % 6].1
+		{
 			v
-		} else {
+		}
+		else
+		{
 			dist_to_land
 		};
 		let d = (n1 + n2 + dist_to_land) / 3.0;
 		uvs.push(Vec2::new(0.0, d.remap(0., 4., 1.0, 0.0)));
 		normals.push(Vec3::Y);
 	}
-	for i in 0..3 {
+	for i in 0..3
+	{
 		let off = i * 2;
 		indices.push(off + idx);
 		indices.push(((off + 1) % 6) + idx);
@@ -198,13 +215,15 @@ fn crate_tile_water_shore_surface(
 	uvs: &mut Vec<Vec2>,
 	indices: &mut Vec<u32>,
 	normals: &mut Vec<Vec3>,
-) {
+)
+{
 	let idx = verts.len() as u32;
 	//todo: only use triangle fan when on shoreline
 	verts.push(pos);
 	uvs.push(Vec2::new(0.0, dist_to_land.remap(0., 4., 1.0, 0.0)));
 	normals.push(Vec3::Y);
-	for i in 0..12 {
+	for i in 0..12
+	{
 		let p = pos + WATER_HEX_CORNERS[i];
 		verts.push(p);
 		let ni = i / 2;
@@ -212,16 +231,21 @@ fn crate_tile_water_shore_surface(
 		let nn = neighbors[(ni + 5) % 6];
 		let mut uv = Vec2::new(0.0, dist_to_land.remap(0., 4., 1.0, 0.0));
 
-		if nn.0 > pos.y || n.0 > pos.y {
+		if nn.0 > pos.y || n.0 > pos.y
+		{
 			uv.x = 1.0;
 		}
-		if ni * 2 != i {
+		if ni * 2 != i
-			if n.0 <= pos.y {
+		{
+			if n.0 <= pos.y
+			{
 				uv.x = 0.0;
 			}
 			let d = if let Some(v) = n.1 { v } else { dist_to_land };
 			uv.y = ((d + dist_to_land) / 2.0).remap(0., 4., 1.0, 0.0);
-		} else {
+		}
+		else
+		{
 			let d = if let Some(v) = n.1 { v } else { dist_to_land };
 			let d2 = if let Some(v) = nn.1 { v } else { dist_to_land };
 			uv.y = ((d + d2 + dist_to_land) / 3.0).remap(0., 4., 1.0, 0.0);
@@ -245,7 +269,8 @@ fn create_tile_wall(
 	indices: &mut Vec<u32>,
 	normals: &mut Vec<Vec3>,
 	tex_off: Vec2,
-) {
+)
+{
 	let p1 = HEX_CORNERS[(dir) % 6] + pos;
 	let p2 = HEX_CORNERS[(dir + 1) % 6] + pos;
 	let p3 = Vec3::new(p1.x, height, p1.z);
@@ -279,12 +304,14 @@ fn create_tile_wall(
 }
 
 #[cfg(test)]
-mod tests {
+mod tests
+{
 
 	use super::*;
 
 	#[test]
-	fn generate_tile_wall() {
+	fn generate_tile_wall()
+	{
 		let mut verts = Vec::new();
 		let mut uvs = Vec::new();
 		let mut normals = Vec::new();
@@ -311,7 +338,8 @@ mod tests {
 	}
 
 	#[test]
-	fn generate_tile() {
+	fn generate_tile()
+	{
 		let mut verts = Vec::new();
 		let mut uvs = Vec::new();
 		let mut normals = Vec::new();

engine/world_generation/src/generators/packed_mesh_generator.rs

@@ -1,24 +1,25 @@
-use crate::hex_utils::{offset3d_to_world, HexCoord};
 use crate::prelude::*;
+use bevy::asset::RenderAssetUsages;
 use bevy::{
+	mesh::{Indices, PrimitiveTopology},
 	prelude::*,
-	render::{
-		mesh::{Indices, PrimitiveTopology},
-		render_asset::RenderAssetUsages,
-	},
 };
+use hex::prelude::*;
 
-pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh {
+pub fn generate_packed_chunk_mesh(chunk: &MeshChunkData) -> Mesh
+{
 	let vertex_count: usize = Chunk::SIZE * Chunk::SIZE * 6;
 	let mut packed_data = Vec::with_capacity(vertex_count);
 	let mut indices = Vec::with_capacity(vertex_count);
 	let mut heights = Vec::with_capacity(vertex_count);
 
-	for z in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
-		for x in 0..Chunk::SIZE {
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let idx = x + z * Chunk::SIZE;
 			let height = chunk.heights[idx];
-			let coord = HexCoord::from_grid_pos(x, z);
+			let coord = HexCoord::from_offset_pos(x, z);
 			let n = chunk.get_neighbors(&coord);
 
 			create_packed_tile(
@@ -53,12 +54,14 @@ fn create_packed_tile(
 	heights: &mut Vec<f32>,
 	texture_index: u32,
 	side_texture_index: u32,
-) {
+)
+{
 	let idx = packed_data.len() as u32;
 
 	packed_data.push(pack_vertex_data(offset, 0, texture_index));
 	heights.push(height);
-	for i in 0..6 {
+	for i in 0..6
+	{
 		packed_data.push(pack_vertex_data(offset, i + 1, texture_index));
 		indices.push(idx);
 		indices.push(idx + 1 + i as u32);
@@ -66,9 +69,11 @@ fn create_packed_tile(
 		heights.push(height);
 	}
 
-	for i in 0..neighbors.len() {
+	for i in 0..neighbors.len()
+	{
 		let n_height = neighbors[i];
-		if n_height < height {
+		if n_height < height
+		{
 			create_packed_tile_wall(
 				offset,
 				height,
@@ -92,7 +97,8 @@ fn create_packed_tile_wall(
 	indices: &mut Vec<u32>,
 	heights: &mut Vec<f32>,
 	side_texture_index: u32,
-) {
+)
+{
 	let idx = packed_data.len() as u32;
 
 	let side_2 = ((side + 1) % 6) + 1;
@@ -115,7 +121,8 @@ fn create_packed_tile_wall(
 	indices.push(idx + 3);
 }
 
-fn pack_vertex_data(offset: UVec2, vert: usize, tex: u32) -> u32 {
+fn pack_vertex_data(offset: UVec2, vert: usize, tex: u32) -> u32
+{
 	//6 + 6 bits offset
 	//4 bits vert
 	//12 bits texture

engine/world_generation/src/heightmap.rs

@@ -3,6 +3,7 @@ use core::f32;
 use bevy::math::{IVec2, UVec2};
 use bevy::prelude::{FloatExt, Vec2};
 use bevy::utils::default;
+use hex::prelude::*;
 use noise::{NoiseFn, Simplex, SuperSimplex};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
@@ -10,7 +11,8 @@ use crate::biome_painter::BiomePainter;
 use crate::map::biome_map::{BiomeChunk, BiomeData, BiomeMap};
 use crate::prelude::*;
 
-pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> (Map, BiomeMap) {
+pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePainter) -> (Map, BiomeMap)
+{
 	let biomes = generate_biomes(cfg, seed, painter);
 	let biomes_borrow = &biomes;
 	// let mut chunks: Vec<Chunk> = Vec::with_capacity(cfg.size.length_squared() as usize);
@@ -25,11 +27,14 @@ pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePain
 		.collect();
 	let mut min = f32::MAX;
 	let mut max = f32::MIN;
-	for chunk in &chunks {
+	for chunk in &chunks
-		if chunk.min_level < min {
+	{
+		if chunk.min_level < min
+		{
 			min = chunk.min_level;
 		}
-		if chunk.max_level > max {
+		if chunk.max_level > max
+		{
 			max = chunk.max_level;
 		}
 	}
@@ -48,7 +53,8 @@ pub fn generate_heightmap(cfg: &GenerationConfig, seed: u32, painter: &BiomePain
 	);
 }
 
-pub fn generate_biomes(cfg: &GenerationConfig, seed: u32, biome_painter: &BiomePainter) -> BiomeMap {
+pub fn generate_biomes(cfg: &GenerationConfig, seed: u32, biome_painter: &BiomePainter) -> BiomeMap
+{
 	let mut map = BiomeMap::new(cfg.size, biome_painter.biomes.len());
 	map.chunks = (0..cfg.size.y)
 		.into_par_iter()
@@ -68,7 +74,8 @@ pub fn generate_biome_chunk(
 	cfg: &GenerationConfig,
 	seed: u32,
 	biome_painter: &BiomePainter,
-) -> BiomeChunk {
+) -> BiomeChunk
+{
 	let mut chunk = BiomeChunk {
 		offset: UVec2::new(chunk_x as u32, chunk_y as u32),
 		data: [BiomeData::default(); Chunk::AREA],
@@ -78,8 +85,10 @@ pub fn generate_biome_chunk(
 	let noise_t = Simplex::new(seed + 2);
 	let noise_c = Simplex::new(seed + 3);
 
-	for z in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
-		for x in 0..Chunk::SIZE {
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let moisture = sample_point(
 				x as f64 + chunk_x as f64 * Chunk::SIZE as f64,
 				z as f64 + chunk_y as f64 * Chunk::SIZE as f64,
@@ -123,14 +132,16 @@ pub fn generate_biome_chunk(
 	return chunk;
 }
 
-pub fn generate_noise_map(size: UVec2, seed: u32, cfg: &NoiseConfig, border_size: f32) -> Vec<f32> {
+pub fn generate_noise_map(size: UVec2, seed: u32, cfg: &NoiseConfig, border_size: f32) -> Vec<f32>
+{
 	let noise = SuperSimplex::new(seed);
 
 	let data: Vec<_> = (0..(size.y as usize * Chunk::SIZE))
 		.into_par_iter()
 		.flat_map(|y| {
 			let mut row = Vec::with_capacity(size.x as usize * Chunk::SIZE);
-			for x in 0..row.capacity() {
+			for x in 0..row.capacity()
+			{
 				row.push(sample_point(
 					x as f64,
 					y as f64,
@@ -154,21 +165,26 @@ pub fn generate_chunk(
 	seed: u32,
 	biome_chunk: &BiomeChunk,
 	biome_painter: &BiomePainter,
-) -> Chunk {
+) -> Chunk
+{
 	let mut result: [f32; Chunk::SIZE * Chunk::SIZE] = [0.; Chunk::AREA];
 	let mut data = [BiomeData::default(); Chunk::AREA];
 	let mut biome_ids = [0; Chunk::AREA];
 	let noise = Simplex::new(seed);
 	let mut min = f32::MAX;
 	let mut max = f32::MIN;
-	for z in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
-		for x in 0..Chunk::SIZE {
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let biome_data = biome_chunk.get_biome_data(x, z);
 			let biome_blend = biome_chunk.get_biome(x, z);
 			let mut sample = 0.;
-			for i in 0..biome_blend.len() {
+			for i in 0..biome_blend.len()
+			{
 				let blend = biome_blend[i];
-				if blend == 0. {
+				if blend == 0.
+				{
 					continue;
 				}
 				let biome = &biome_painter.biomes[i];
@@ -185,10 +201,12 @@ pub fn generate_chunk(
 			let idx = x + z * Chunk::SIZE;
 			biome_ids[idx] = biome_chunk.get_biome_id_dithered(x, z, &noise, cfg.biome_dither);
 			result[idx] = sample;
-			if sample > max {
+			if sample > max
+			{
 				max = sample;
 			}
-			if sample < min {
+			if sample < min
+			{
 				min = sample;
 			}
 			data[idx] = biome_data.clone();
@@ -212,23 +230,29 @@ fn sample_point(
 	size: Vec2,
 	border_size: f32,
 	border_value: f32,
-) -> f32 {
+) -> f32
+{
 	let x_s = x / cfg.scale;
 	let z_s = z / cfg.scale;
 
 	let mut elevation: f64 = 0.;
-	for i in 0..cfg.layers.len() {
+	for i in 0..cfg.layers.len()
+	{
 		let value: f64;
 		let layer = &cfg.layers[i];
-		if layer.is_rigid {
+		if layer.is_rigid
+		{
 			value = sample_rigid(x_s, z_s, layer, noise);
-		} else {
+		}
+		else
+		{
 			value = sample_simple(x_s, z_s, layer, noise);
 		}
 		elevation += value;
 	}
 
-	if border_size == 0.0 {
+	if border_size == 0.0
+	{
 		return elevation as f32;
 	}
 
@@ -243,12 +267,14 @@ fn sample_point(
 	return border_value.lerp(elevation as f32, d);
 }
 
-fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64 {
+fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64
+{
 	let mut freq: f64 = cfg.base_roughness;
 	let mut amp: f64 = 1.;
 	let mut value = 0.;
 
-	for _ in 0..cfg.layers {
+	for _ in 0..cfg.layers
+	{
 		let v = noise.get([x * freq, z * freq]);
 		value += (v + 1.) * 0.5 * amp;
 		freq *= cfg.roughness;
@@ -257,12 +283,14 @@ fn sample_simple(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64,
 	value -= cfg.min_value;
 	return value * cfg.strength;
 }
-fn sample_rigid(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64 {
+fn sample_rigid(x: f64, z: f64, cfg: &GeneratorLayer, noise: &impl NoiseFn<f64, 2>) -> f64
+{
 	let mut freq: f64 = cfg.base_roughness;
 	let mut amp: f64 = 1.;
 	let mut value = 0.;
 	let mut weight = 1.;
-	for _ in 0..cfg.layers {
+	for _ in 0..cfg.layers
+	{
 		let mut v = 1. - noise.get([x * freq, z * freq]).abs();
 		v *= v;
 		v *= weight;

engine/world_generation/src/lib.rs

@@ -1,11 +1,10 @@
+pub mod biome_asset;
 pub mod biome_painter;
 pub mod consts;
 pub mod generators;
 pub mod heightmap;
-pub mod hex_utils;
 pub mod map;
 pub mod prelude;
 pub mod states;
 pub mod tile_manager;
 pub mod tile_mapper;
-pub mod biome_asset;

engine/world_generation/src/map/biome_map.rs

@@ -5,10 +5,11 @@ use bevy::{
 use noise::NoiseFn;
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
-use super::chunk::Chunk;
+use hex::prelude::*;
 
 #[derive(Clone, Resource)]
-pub struct BiomeMap {
+pub struct BiomeMap
+{
 	pub height: usize,
 	pub width: usize,
 	pub size: UVec2,
@@ -17,26 +18,33 @@ pub struct BiomeMap {
 }
 
 #[derive(Default, Clone, Copy)]
-pub struct BiomeData {
+pub struct BiomeData
+{
 	pub moisture: f32,
 	pub temperature: f32,
 	pub continentality: f32,
 }
 
-impl Into<Vec3> for &BiomeData {
+impl Into<Vec3> for &BiomeData
-	fn into(self) -> Vec3 {
+{
+	fn into(self) -> Vec3
+	{
 		return Vec3::new(self.moisture, self.temperature, self.continentality);
 	}
 }
 
-impl Into<Vec3> for BiomeData {
+impl Into<Vec3> for BiomeData
-	fn into(self) -> Vec3 {
+{
+	fn into(self) -> Vec3
+	{
 		return Vec3::new(self.moisture, self.temperature, self.continentality);
 	}
 }
 
-impl BiomeMap {
+impl BiomeMap
-	pub fn new(size: UVec2, biome_count: usize) -> Self {
+{
+	pub fn new(size: UVec2, biome_count: usize) -> Self
+	{
 		let len = size.x as usize * size.y as usize * Chunk::AREA;
 		return BiomeMap {
 			size,
@@ -47,14 +55,17 @@ impl BiomeMap {
 		};
 	}
 
-	pub fn blend(&mut self, count: usize) {
+	pub fn blend(&mut self, count: usize)
+	{
 		assert!(count != 0, "Count cannot be 0");
-		for _ in 0..count {
+		for _ in 0..count
+		{
 			self.blend_once();
 		}
 	}
 
-	fn blend_once(&mut self) {
+	fn blend_once(&mut self)
+	{
 		let c: Vec<BiomeChunk> = (0..self.chunks.len())
 			.into_par_iter()
 			.map(|i| &self.chunks[i])
@@ -63,7 +74,8 @@ impl BiomeMap {
 					.into_par_iter()
 					.map(|y| {
 						let mut new_tiles = Vec::with_capacity(self.width);
-						for x in 0..Chunk::SIZE {
+						for x in 0..Chunk::SIZE
+						{
 							let tx = x as u32 + chunk.offset.x * Chunk::SIZE as u32;
 							let ty = y as u32 + chunk.offset.y * Chunk::SIZE as u32;
 							let kernel = self.get_kernel(tx as i32, ty as i32);
@@ -76,7 +88,8 @@ impl BiomeMap {
 								});
 
 							let sum: f32 = r.iter().sum();
-							if sum == 0. {
+							if sum == 0.
+							{
 								new_tiles.push(vec![0.; self.biome_count]);
 								continue;
 							}
@@ -96,7 +109,8 @@ impl BiomeMap {
 		self.chunks = c;
 	}
 
-	fn get_kernel(&self, x: i32, y: i32) -> [Option<&Vec<f32>>; 9] {
+	fn get_kernel(&self, x: i32, y: i32) -> [Option<&Vec<f32>>; 9]
+	{
 		return [
 			self.get_biome(x - 1, y - 1),
 			self.get_biome(x, y - 1),
@@ -110,11 +124,14 @@ impl BiomeMap {
 		];
 	}
 
-	pub fn get_biome(&self, x: i32, y: i32) -> Option<&Vec<f32>> {
+	pub fn get_biome(&self, x: i32, y: i32) -> Option<&Vec<f32>>
-		if x < 0 || y < 0 {
+	{
+		if x < 0 || y < 0
+		{
 			return None;
 		}
-		if x >= self.width as i32 || y >= self.height as i32 {
+		if x >= self.width as i32 || y >= self.height as i32
+		{
 			return None;
 		}
 
@@ -125,7 +142,8 @@ impl BiomeMap {
 		return Some(chunk.get_biome(x as usize - cx * Chunk::SIZE, y as usize - cy * Chunk::SIZE));
 	}
 
-	pub fn get_biome_id(&self, x: usize, y: usize) -> usize {
+	pub fn get_biome_id(&self, x: usize, y: usize) -> usize
+	{
 		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
 		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
 
@@ -134,7 +152,8 @@ impl BiomeMap {
 		return chunk.get_biome_id(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE));
 	}
 
-	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
+	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize
+	{
 		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
 		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
 
@@ -143,7 +162,8 @@ impl BiomeMap {
 		return chunk.get_biome_id_dithered(x - (cx * Chunk::SIZE), y - (cy * Chunk::SIZE), noise, scale);
 	}
 
-	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
+	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData
+	{
 		let cx = (x as f32 / Chunk::SIZE as f32).floor() as usize;
 		let cy = (y as f32 / Chunk::SIZE as f32).floor() as usize;
 
@@ -154,28 +174,35 @@ impl BiomeMap {
 }
 
 #[derive(Clone)]
-pub struct BiomeChunk {
+pub struct BiomeChunk
+{
 	pub tiles: Vec<Vec<f32>>,
 	pub offset: UVec2,
 	pub data: [BiomeData; Chunk::AREA],
 }
 
-impl BiomeChunk {
+impl BiomeChunk
-	pub fn get_biome(&self, x: usize, y: usize) -> &Vec<f32> {
+{
+	pub fn get_biome(&self, x: usize, y: usize) -> &Vec<f32>
+	{
 		return &self.tiles[x + y * Chunk::SIZE];
 	}
 
-	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData {
+	pub fn get_biome_data(&self, x: usize, y: usize) -> &BiomeData
+	{
 		return &self.data[x + y * Chunk::SIZE];
 	}
 
-	pub fn get_biome_id(&self, x: usize, y: usize) -> usize {
+	pub fn get_biome_id(&self, x: usize, y: usize) -> usize
+	{
 		let b = self.get_biome(x, y);
 		let mut max = 0.;
 		let mut idx = 0;
-		for i in 0..b.len() {
+		for i in 0..b.len()
+		{
 			let blend = b[i];
-			if blend > max {
+			if blend > max
+			{
 				max = blend;
 				idx = i;
 			}
@@ -183,17 +210,21 @@ impl BiomeChunk {
 		return idx;
 	}
 
-	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize {
+	pub fn get_biome_id_dithered(&self, x: usize, y: usize, noise: &impl NoiseFn<f64, 2>, scale: f64) -> usize
+	{
 		let mut cur_id = self.get_biome_id(x, y);
 		let b = self.get_biome(x, y);
-		let n = (noise.get([x as f64 / scale, y as f64 / scale]) as f32 - 0.5)/ 2.0;
+		let n = (noise.get([x as f64 / scale, y as f64 / scale]) as f32 - 0.5) / 2.0;
 		let mut max = b[cur_id] + n;
-		for i in 0..b.len() {
+		for i in 0..b.len()
+		{
 			let blend = b[i];
-			if blend == 0. {
+			if blend == 0.
+			{
 				continue;
 			}
-			if blend > max {
+			if blend > max
+			{
 				max = blend + n;
 				cur_id = i;
 			}
@@ -204,18 +235,22 @@ impl BiomeChunk {
 }
 
 #[cfg(test)]
-mod tests {
+mod tests
+{
 
 	use super::*;
 
 	#[test]
-	fn biome_blend() {
+	fn biome_blend()
+	{
 		let mut biome = BiomeMap::new(UVec2::splat(4), 8);
 		let w = biome.size.x as usize;
 		let h = biome.size.y as usize;
 
-		for y in 0..h {
+		for y in 0..h
-			for x in 0..w {
+		{
+			for x in 0..w
+			{
 				let mut b = vec![0.; biome.biome_count];
 				let idx = (x + y) % biome.biome_count;
 				b[idx] = 1.;
@@ -227,7 +262,8 @@ mod tests {
 		assert!(biome.chunks.iter().all(|f| f.tiles.len() == Chunk::AREA), "Data Lost");
 	}
 
-	fn generate_chunk(x: usize, y: usize, biome: Vec<f32>) -> BiomeChunk {
+	fn generate_chunk(x: usize, y: usize, biome: Vec<f32>) -> BiomeChunk
+	{
 		let chunk = BiomeChunk {
 			offset: UVec2::new(x as u32, y as u32),
 			data: [BiomeData::default(); Chunk::AREA],

engine/world_generation/src/map/config.rs

@@ -2,11 +2,12 @@ use bevy::prelude::*;
 use bevy_inspector_egui::InspectorOptions;
 use serde::{Deserialize, Serialize};
 
-use super::chunk::Chunk;
+use hex::prelude::*;
 
 #[derive(Resource, Reflect, Default, Clone)]
 #[reflect(Resource)]
-pub struct GenerationConfig {
+pub struct GenerationConfig
+{
 	pub sea_level: f64,
 	pub border_size: f32,
 	pub biome_blend: usize,
@@ -17,23 +18,28 @@ pub struct GenerationConfig {
 	pub size: UVec2,
 }
 
-impl GenerationConfig {
+impl GenerationConfig
-	pub fn get_total_width(&self) -> usize {
+{
+	pub fn get_total_width(&self) -> usize
+	{
 		return self.size.x as usize * Chunk::SIZE;
 	}
-	pub fn get_total_height(&self) -> usize {
+	pub fn get_total_height(&self) -> usize
+	{
 		return self.size.y as usize * Chunk::SIZE;
 	}
 }
 
 #[derive(Serialize, Deserialize, Default, Reflect, Clone, Debug)]
-pub struct NoiseConfig {
+pub struct NoiseConfig
+{
 	pub scale: f64,
 	pub layers: Vec<GeneratorLayer>,
 }
 
 #[derive(Reflect, InspectorOptions, Serialize, Deserialize, Debug, Clone, Default)]
-pub struct GeneratorLayer {
+pub struct GeneratorLayer
+{
 	pub strength: f64,
 	pub min_value: f64,
 	pub base_roughness: f64,

engine/world_generation/src/map/map.rs

@@ -1,14 +1,11 @@
 use bevy::prelude::*;
+use hex::prelude::*;
 
-use crate::hex_utils::*;
+use super::mesh_chunk::MeshChunkData;
-
-use super::{
-	chunk::Chunk,
-	mesh_chunk::MeshChunkData,
-};
 
 #[derive(Resource, Clone)]
-pub struct Map {
+pub struct Map
+{
 	pub chunks: Vec<Chunk>,
 	pub height: usize,
 	pub width: usize,
@@ -18,20 +15,25 @@ pub struct Map {
 	pub biome_count: usize,
 }
 
-impl Map {
+impl Map
-	pub fn get_tile_count(&self) -> usize {
+{
+	pub fn get_tile_count(&self) -> usize
+	{
 		return self.get_tile_width() * self.get_tile_height();
 	}
 
-	pub fn get_tile_width(&self) -> usize {
+	pub fn get_tile_width(&self) -> usize
+	{
 		return self.width * Chunk::SIZE;
 	}
 
-	pub fn get_tile_height(&self) -> usize {
+	pub fn get_tile_height(&self) -> usize
+	{
 		return self.height * Chunk::SIZE;
 	}
 
-	pub fn get_chunk_mesh_data(&self, chunk_index: usize) -> MeshChunkData {
+	pub fn get_chunk_mesh_data(&self, chunk_index: usize) -> MeshChunkData
+	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Chunk Mesh Data").entered();
 		let chunk = &self.chunks[chunk_index];
@@ -45,36 +47,45 @@ impl Map {
 		};
 	}
 
-	fn get_distance_from_land(&self, chunk_offset: IVec2, range: usize) -> [f32; Chunk::AREA] {
+	fn get_distance_from_land(&self, chunk_offset: IVec2, range: usize) -> [f32; Chunk::AREA]
+	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Chunk Land Dist Data").entered();
 		let mut dists = [0.0; Chunk::AREA];
 		let cx = chunk_offset.x as usize * Chunk::SIZE;
 		let cz = chunk_offset.y as usize * Chunk::SIZE;
-		for z in 0..Chunk::SIZE {
+		for z in 0..Chunk::SIZE
-			for x in 0..Chunk::SIZE {
+		{
-				let coord = HexCoord::from_grid_pos(x + cx, z + cz);
+			for x in 0..Chunk::SIZE
+			{
+				let coord = HexCoord::from_offset_pos(x + cx, z + cz);
 				let index = coord.to_chunk_local_index();
 
-				if !self.is_in_bounds(&coord) {
+				if !self.is_in_bounds(&coord)
+				{
 					warn!("Coord is not in bounds!?");
 				}
 
 				//Current tile is land tile
-				if self.sample_height(&coord) > self.sealevel {
+				if self.sample_height(&coord) > self.sealevel
+				{
 					dists[index] = 0.0;
 					continue;
 				}
 
 				//Find closest land tile
 				if let Some(d) = self.hex_select_first(&coord, range, false, |_t, h, r| {
-					if h > self.sealevel {
+					if h > self.sealevel
+					{
 						return Some(r as f32);
 					}
 					return None;
-				}) {
+				})
+				{
 					dists[index] = d;
-				} else {
+				}
+				else
+				{
 					dists[index] = range as f32;
 				}
 			}
@@ -82,14 +93,17 @@ impl Map {
 		return dists;
 	}
 
-	pub fn get_neighbors(&self, pos: &HexCoord) -> [Option<f32>; 6] {
+	pub fn get_neighbors(&self, pos: &HexCoord) -> [Option<f32>; 6]
+	{
 		let mut results: [Option<f32>; 6] = [None; 6];
 		let w = self.width * Chunk::SIZE;
 		let h = self.height * Chunk::SIZE;
 		let n_tiles = pos.get_neighbors();
-		for i in 0..6 {
+		for i in 0..6
+		{
 			let n_tile = n_tiles[i];
-			if !n_tile.is_in_bounds(h, w) {
+			if !n_tile.is_in_bounds(h, w)
+			{
 				continue;
 			}
 			let c_idx = n_tile.to_chunk_index(self.width);
@@ -100,7 +114,8 @@ impl Map {
 		return results;
 	}
 
-	pub fn sample_height(&self, pos: &HexCoord) -> f32 {
+	pub fn sample_height(&self, pos: &HexCoord) -> f32
+	{
 		assert!(
 			self.is_in_bounds(pos),
 			"The provided coordinate is not within the map bounds"
@@ -110,7 +125,8 @@ impl Map {
 		return chunk.heights[pos.to_chunk_local_index()];
 	}
 
-	pub fn sample_height_mut(&mut self, pos: &HexCoord) -> &mut f32 {
+	pub fn sample_height_mut(&mut self, pos: &HexCoord) -> &mut f32
+	{
 		assert!(
 			self.is_in_bounds(pos),
 			"The provided coordinate is not within the map bounds"
@@ -120,11 +136,13 @@ impl Map {
 		return &mut chunk.heights[pos.to_chunk_local_index()];
 	}
 
-	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool {
+	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool
+	{
 		return pos.is_in_bounds(self.height * Chunk::SIZE, self.width * Chunk::SIZE);
 	}
 
-	pub fn get_biome_id(&self, pos: &HexCoord) -> usize {
+	pub fn get_biome_id(&self, pos: &HexCoord) -> usize
+	{
 		assert!(
 			self.is_in_bounds(pos),
 			"The provided coordinate is not within the map bounds"
@@ -134,13 +152,15 @@ impl Map {
 		return chunk.biome_id[pos.to_chunk_local_index()];
 	}
 
-	pub fn get_center(&self) -> Vec3 {
+	pub fn get_center(&self) -> Vec3
+	{
 		let w = self.get_world_width();
 		let h = self.get_world_height();
 		return Vec3::new(w / 2., self.sealevel, h / 2.);
 	}
 
-	pub fn get_center_with_height(&self) -> Vec3 {
+	pub fn get_center_with_height(&self) -> Vec3
+	{
 		let w = self.get_world_width();
 		let h = self.get_world_height();
 		let mut pos = Vec3::new(w / 2., self.sealevel, h / 2.);
@@ -148,22 +168,27 @@ impl Map {
 		return pos;
 	}
 
-	pub fn get_world_width(&self) -> f32 {
+	pub fn get_world_width(&self) -> f32
+	{
 		return (self.width * Chunk::SIZE) as f32 * SHORT_DIAGONAL;
 	}
-	pub fn get_world_height(&self) -> f32 {
+	pub fn get_world_height(&self) -> f32
+	{
 		return (self.height * Chunk::SIZE) as f32 * 1.5;
 	}
 
-	pub fn get_world_size(&self) -> Vec2 {
+	pub fn get_world_size(&self) -> Vec2
+	{
 		return Vec2::new(self.get_world_width(), self.get_world_height());
 	}
 
-	pub fn set_height(&mut self, pos: &HexCoord, height: f32) {
+	pub fn set_height(&mut self, pos: &HexCoord, height: f32)
+	{
 		self.chunks[pos.to_chunk_index(self.width)].heights[pos.to_chunk_local_index()] = height;
 	}
 
-	pub fn create_crater(&mut self, pos: &HexCoord, radius: usize, depth: f32) -> Vec<(HexCoord, f32)> {
+	pub fn create_crater(&mut self, pos: &HexCoord, radius: usize, depth: f32) -> Vec<(HexCoord, f32)>
+	{
 		assert!(radius != 0, "Radius cannot be zero");
 
 		let tiles = self.hex_select_mut(pos, radius, true, |p, h, r| {
@@ -184,22 +209,30 @@ impl Map {
 	{
 		assert!(radius != 0, "Radius cannot be zero");
 
-		let mut result = if include_center {
+		let mut result = if include_center
+		{
 			Vec::with_capacity(get_tile_count_in_range(radius) + 1)
-		} else {
+		}
+		else
+		{
 			Vec::with_capacity(get_tile_count_in_range(radius))
 		};
-		if include_center {
+		if include_center
+		{
 			let h = self.sample_height(&center);
 			result.push((op)(center, h, 0));
 		}
 
-		for k in 0..(radius + 1) {
+		for k in 0..(radius + 1)
+		{
 			let mut p = center.scale(4, k);
-			for i in 0..6 {
+			for i in 0..6
-				for _j in 0..k {
+			{
+				for _j in 0..k
+				{
 					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p) {
+					if self.is_in_bounds(&p)
+					{
 						let h = self.sample_height(&p);
 						result.push((op)(&p, h, k));
 					}
@@ -222,23 +255,30 @@ impl Map {
 	{
 		assert!(radius != 0, "Radius cannot be zero");
 
-		if include_center {
+		if include_center
+		{
 			let h = self.sample_height(&center);
 			let r = (op)(center, h, 0);
-			if r.is_some() {
+			if r.is_some()
+			{
 				return r;
 			}
 		}
 
-		for k in 0..(radius + 1) {
+		for k in 0..(radius + 1)
+		{
 			let mut p = center.scale(4, k);
-			for i in 0..6 {
+			for i in 0..6
-				for _j in 0..k {
+			{
+				for _j in 0..k
+				{
 					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p) {
+					if self.is_in_bounds(&p)
+					{
 						let h = self.sample_height(&p);
 						let r = (op)(&p, h, k);
-						if r.is_some() {
+						if r.is_some()
+						{
 							return r;
 						}
 					}
@@ -265,15 +305,20 @@ impl Map {
 			"Start radius cannot be lower than end radius"
 		);
 
-		for k in start_radius..(end_radius + 1) {
+		for k in start_radius..(end_radius + 1)
+		{
 			let mut p = center.scale(4, k);
-			for i in 0..6 {
+			for i in 0..6
-				for _j in 0..k {
+			{
+				for _j in 0..k
+				{
 					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p) {
+					if self.is_in_bounds(&p)
+					{
 						let h = self.sample_height(&p);
 						let r = (op)(&p, h, k);
-						if r.is_some() {
+						if r.is_some()
+						{
 							return r;
 						}
 					}
@@ -296,22 +341,30 @@ impl Map {
 	{
 		assert!(radius != 0, "Radius cannot be zero");
 
-		let mut result = if include_center {
+		let mut result = if include_center
+		{
 			Vec::with_capacity(get_tile_count_in_range(radius) + 1)
-		} else {
+		}
+		else
+		{
 			Vec::with_capacity(get_tile_count_in_range(radius))
 		};
-		if include_center {
+		if include_center
+		{
 			let h = self.sample_height_mut(&center);
 			result.push((op)(center, h, 0));
 		}
 
-		for k in 0..(radius + 1) {
+		for k in 0..(radius + 1)
+		{
 			let mut p = center.scale(4, k);
-			for i in 0..6 {
+			for i in 0..6
-				for _j in 0..k {
+			{
+				for _j in 0..k
+				{
 					p = p.get_neighbor(i);
-					if self.is_in_bounds(&p) {
+					if self.is_in_bounds(&p)
+					{
 						let h = self.sample_height_mut(&p);
 						result.push((op)(&p, h, k));
 					}

engine/world_generation/src/map/map_utils.rs

@@ -1,19 +1,20 @@
 use std::ops::Add;
 
-use bevy::{asset::AssetLoader, math::VectorSpace, prelude::*};
+use bevy::{math::VectorSpace, prelude::*};
 use image::ImageBuffer;
 use rayon::prelude::*;
 
-use crate::hex_utils::HexCoord;
+use hex::prelude::*;
 
-use super::{biome_map::BiomeMap, chunk::Chunk, map::Map};
+use super::{biome_map::BiomeMap, map::Map};
 
 pub fn render_image(
 	size: UVec2,
 	data: &Vec<f32>,
 	color1: LinearRgba,
 	color2: LinearRgba,
-) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
+) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+{
 	let mut image = ImageBuffer::new(size.x * Chunk::SIZE as u32, size.y * Chunk::SIZE as u32);
 	update_image(size, data, color1, color2, &mut image);
 
@@ -26,7 +27,8 @@ pub fn update_image(
 	color1: LinearRgba,
 	color2: LinearRgba,
 	image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>,
-) {
+)
+{
 	let min = *data.iter().min_by(|a, b| a.partial_cmp(b).unwrap()).unwrap_or(&0.0);
 	let max = *data.iter().min_by(|a, b| a.partial_cmp(b).unwrap()).unwrap_or(&1.0);
 
@@ -41,7 +43,8 @@ pub fn update_image(
 	});
 }
 
-fn to_pixel(col: &LinearRgba) -> image::Rgba<u8> {
+fn to_pixel(col: &LinearRgba) -> image::Rgba<u8>
+{
 	return image::Rgba([
 		(col.red * 255.0) as u8,
 		(col.green * 255.0) as u8,
@@ -49,7 +52,8 @@ fn to_pixel(col: &LinearRgba) -> image::Rgba<u8> {
 		255,
 	]);
 }
-pub fn render_map(map: &Map, smooth: f32) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
+pub fn render_map(map: &Map, smooth: f32) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+{
 	let mut image = ImageBuffer::new(
 		map.width as u32 * Chunk::SIZE as u32,
 		map.height as u32 * Chunk::SIZE as u32,
@@ -57,18 +61,21 @@ pub fn render_map(map: &Map, smooth: f32) -> ImageBuffer<image::Rgba<u8>, Vec<u8
 	update_map(map, smooth, &mut image);
 	return image;
 }
-pub fn update_map(map: &Map, smooth: f32, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>) {
+pub fn update_map(map: &Map, smooth: f32, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>)
+{
 	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
-		let coord = HexCoord::from_grid_pos(x as usize, y as usize);
+		let coord = HexCoord::from_offset_pos(x as usize, y as usize);
 		let right = coord.get_neighbor(1);
 		let height = map.sample_height(&coord);
 
 		let mut color = Hsla::hsl(138.0, 1.0, 0.4);
-		if height < map.sealevel {
+		if height < map.sealevel
+		{
 			color.hue = 217.0;
 		}
 
-		if map.is_in_bounds(&right) {
+		if map.is_in_bounds(&right)
+		{
 			let h2 = map.sample_height(&right);
 			color = get_height_color_blend(color, height, h2, smooth);
 		}
@@ -77,22 +84,33 @@ pub fn update_map(map: &Map, smooth: f32, image: &mut ImageBuffer<image::Rgba<u8
 	});
 }
 
-fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f32) -> Hsla {
+fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f32) -> Hsla
+{
 	let mut color = base_color;
 	let mut d = height2 - height;
-	if smooth == 0.0 || d.abs() > smooth {
+	if smooth == 0.0 || d.abs() > smooth
-		if d > 0.0 {
+	{
+		if d > 0.0
+		{
 			color.lightness += 0.1;
-		} else if d < 0.0 {
+		}
+		else if d < 0.0
+		{
 			color.lightness -= 0.1;
 		}
-	} else {
+	}
-		if d.abs() <= smooth {
+	else
+	{
+		if d.abs() <= smooth
+		{
 			d /= smooth;
-			if d > 0.0 {
+			if d > 0.0
+			{
 				let c2: LinearRgba = color.with_lightness(color.lightness + 0.1).into();
 				color = LinearRgba::lerp(color.into(), c2, d).into();
-			} else {
+			}
+			else
+			{
 				let c2: LinearRgba = color.with_lightness(color.lightness - 0.1).into();
 				color = LinearRgba::lerp(color.into(), c2, d.abs()).into();
 			}
@@ -102,13 +120,15 @@ fn get_height_color_blend(base_color: Hsla, height: f32, height2: f32, smooth: f
 	return color;
 }
 
-pub fn render_biome_noise_map(map: &BiomeMap, multi: Vec3) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
+pub fn render_biome_noise_map(map: &BiomeMap, multi: Vec3) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+{
 	let mut image = ImageBuffer::new(map.width as u32, map.height as u32);
 	update_biome_noise_map(map, multi, &mut image);
 	return image;
 }
 
-pub fn update_biome_noise_map(map: &BiomeMap, multi: Vec3, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>) {
+pub fn update_biome_noise_map(map: &BiomeMap, multi: Vec3, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>)
+{
 	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
 		let tile = map.get_biome_data(x as usize, y as usize);
 
@@ -121,7 +141,8 @@ pub fn update_biome_noise_map(map: &BiomeMap, multi: Vec3, image: &mut ImageBuff
 	});
 }
 
-pub fn render_biome_map(map: &Map, biome_map: &BiomeMap) -> ImageBuffer<image::Rgba<u8>, Vec<u8>> {
+pub fn render_biome_map(map: &Map, biome_map: &BiomeMap) -> ImageBuffer<image::Rgba<u8>, Vec<u8>>
+{
 	let mut image = ImageBuffer::new(
 		map.width as u32 * Chunk::SIZE as u32,
 		map.height as u32 * Chunk::SIZE as u32,
@@ -130,19 +151,22 @@ pub fn render_biome_map(map: &Map, biome_map: &BiomeMap) -> ImageBuffer<image::R
 	return image;
 }
 
-pub fn update_biome_map(map: &Map, biome_map: &BiomeMap, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>) {
+pub fn update_biome_map(map: &Map, biome_map: &BiomeMap, image: &mut ImageBuffer<image::Rgba<u8>, Vec<u8>>)
+{
 	let map_biome_count = map.biome_count as f32;
 	image.par_enumerate_pixels_mut().for_each(|(x, y, pixel)| {
-		let coord = HexCoord::from_grid_pos(x as usize, y as usize);
+		let coord = HexCoord::from_offset_pos(x as usize, y as usize);
 		let biome_blend = biome_map.get_biome(x as i32, y as i32).unwrap();
 		let right = coord.get_neighbor(1);
 		let mut color = Oklaba::BLACK;
-		for i in 0..biome_blend.len() {
+		for i in 0..biome_blend.len()
+		{
 			let mut c: Oklaba = Hsla::hsl((i as f32 / map_biome_count) * 360.0, 0.8, 0.7).into();
 			c *= biome_blend[i];
 			color = Oklaba::add(c, color.into()).into();
 		}
-		if map.is_in_bounds(&right) {
+		if map.is_in_bounds(&right)
+		{
 			let h1 = map.sample_height(&coord);
 			let h2 = map.sample_height(&right);
 			color = get_height_color_blend(color.into(), h1, h2, 0.5).into();

engine/world_generation/src/map/mesh_chunk.rs

@@ -2,11 +2,10 @@ use std::collections::VecDeque;
 
 use bevy::math::IVec2;
 
-use crate::hex_utils::HexCoord;
+use hex::prelude::*;
 
-use super::chunk::Chunk;
+pub struct MeshChunkData
-
+{
-pub struct MeshChunkData {
 	pub heights: [f32; Chunk::AREA],
 	pub textures: [[u32; 2]; Chunk::AREA],
 	pub min_height: f32,
@@ -14,13 +13,17 @@ pub struct MeshChunkData {
 	pub distance_to_land: [f32; Chunk::AREA],
 }
 
-impl MeshChunkData {
+impl MeshChunkData
-	pub fn get_neighbors(&self, coord: &HexCoord) -> [f32; 6] {
+{
+	pub fn get_neighbors(&self, coord: &HexCoord) -> [f32; 6]
+	{
 		let mut data = [self.min_height; 6];
 		let n_tiles = coord.get_neighbors();
-		for i in 0..6 {
+		for i in 0..6
+		{
 			let n = n_tiles[i];
-			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE) {
+			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE)
+			{
 				continue;
 			}
 			data[i] = self.heights[n.to_index(Chunk::SIZE)];
@@ -29,56 +32,70 @@ impl MeshChunkData {
 		return data;
 	}
 
-	pub fn get_neighbors_with_water_info(&self, coord: &HexCoord) -> ([(f32, Option<f32>); 6], bool) {
+	pub fn get_neighbors_with_water_info(&self, coord: &HexCoord) -> ([(f32, Option<f32>); 6], bool)
+	{
 		let mut has_land = false;
 		let mut data = [(self.min_height, None); 6];
 		let n_tiles = coord.get_neighbors();
-		for i in 0..6 {
+		for i in 0..6
+		{
 			let n = n_tiles[i];
-			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE) {
+			if !n.is_in_bounds(Chunk::SIZE, Chunk::SIZE)
+			{
 				continue;
 			}
 			let idx = n.to_index(Chunk::SIZE);
 			data[i] = (self.heights[idx], Some(self.distance_to_land[idx]));
-			if data[i].0 > self.sealevel {
+			if data[i].0 > self.sealevel
+			{
 				has_land = true;
 			}
 		}
 		return (data, has_land);
 	}
 
-	pub fn caluclate_water_distances(data: &mut Vec<MeshChunkData>, height: usize, width: usize, range: usize) {
+	pub fn caluclate_water_distances(data: &mut Vec<MeshChunkData>, height: usize, width: usize, _range: usize)
+	{
 		let mut open: VecDeque<(HexCoord, f32, usize)> = VecDeque::new();
-		let mut closed: Vec<(HexCoord, f32)> = Vec::new();
+		// let mut closed: Vec<(HexCoord, f32)> = Vec::new();
-		for z in 0..height {
+		for z in 0..height
-			for x in 0..width {
+		{
+			for x in 0..width
+			{
 				let chunk = &mut data[z * height + x];
 				chunk.prepare_chunk_open(x * Chunk::SIZE, z * Chunk::SIZE, &mut open);
 			}
 		}
 	}
 
-	fn prepare_chunk_open(&mut self, offset_x: usize, offset_z: usize, open: &mut VecDeque<(HexCoord, f32, usize)>) {
+	fn prepare_chunk_open(&mut self, offset_x: usize, offset_z: usize, open: &mut VecDeque<(HexCoord, f32, usize)>)
-		for z in 0..Chunk::SIZE {
+	{
-			for x in 0..Chunk::SIZE {
+		for z in 0..Chunk::SIZE
-				let coord = HexCoord::from_grid_pos(x + offset_x, z + offset_z);
+		{
+			for x in 0..Chunk::SIZE
+			{
+				let coord = HexCoord::from_offset_pos(x + offset_x, z + offset_z);
 				let idx = coord.to_chunk_local_index();
 				let h = self.heights[idx];
 				self.distance_to_land[idx] = if h > self.sealevel { 0.0 } else { 4.0 };
-				if h > self.sealevel {
+				if h > self.sealevel
+				{
 					open.push_back((coord, h, 0));
 				}
 			}
 		}
 	}
 
+	#[allow(dead_code)]
+	#[allow(unused)]
 	fn fill_chunk_borders(
 		&mut self,
 		chunks: &Vec<MeshChunkData>,
 		offset: IVec2,
 		open: &mut VecDeque<(HexCoord, f32, usize)>,
 		closed: &mut Vec<(HexCoord, f32)>,
-	) {
+	)
+	{
 		self.prepare_chunk_open(offset.x as usize * Chunk::SIZE, offset.y as usize * Chunk::SIZE, open);
 		todo!("Fill closed list with bordering tiles")
 	}

engine/world_generation/src/map/mod.rs

@@ -1,6 +1,5 @@
-pub mod chunk;
+pub mod biome_map;
-pub mod mesh_chunk;
 pub mod config;
 pub mod map;
-pub mod biome_map;
+pub mod map_utils;
-pub mod map_utils;
+pub mod mesh_chunk;

engine/world_generation/src/prelude.rs

@@ -1,5 +1,4 @@
 pub use crate::consts::*;
-pub use crate::map::chunk::*;
 pub use crate::map::config::*;
 pub use crate::map::map::*;
 pub use crate::map::mesh_chunk::*;

engine/world_generation/src/tile_manager.rs

@@ -1,5 +1,5 @@
 use asset_loader::create_asset_loader;
-use bevy::{asset::Asset, ecs::system::Resource, reflect::TypePath};
+use bevy::{asset::Asset, reflect::TypePath};
 use serde::{Deserialize, Serialize};
 #[derive(Resource, Debug)]
 pub struct TileManager {

game/buildings/Cargo.toml

@@ -6,18 +6,19 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.15.1"
+bevy = "0.18.0"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.28.0"
+bevy_rapier3d = "0.33.0"
-serde = { version = "1.0.204", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.120"
+serde_json = "1.0.149"
-ron = "0.8.1"
+ron = "0.12.0"
-bevy_asset_loader = { version = "0.22.0", features = [
+bevy_asset_loader = { version = "0.25.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
+hex = { path = "../../engine/hex" }
 
 [features]
 tracing = []

game/buildings/src/assets/building_asset.rs

@@ -1,22 +1,25 @@
 use asset_loader::create_asset_loader;
 use bevy::{
+	ecs::relationship::RelatedSpawnerCommands,
 	gltf::{GltfMesh, GltfNode},
 	prelude::*,
 };
 use serde::{Deserialize, Serialize};
-use shared::{component_defination::ComponentDefination, identifiers::ResourceIdentifier, prefab_defination::*};
+use shared::{component_defination::ComponentDefination, identifiers::ResourceIdentifier};
 
 use crate::{
 	buildings::{
-		conduit_building::ResourceConduitInfo, factory_building::FactoryBuildingInfo,
+		basic_building::BasicBuildingInfo, conduit_building::ResourceConduitInfo,
-		resource_gathering::ResourceGatheringBuildingInfo,
+		factory_building::FactoryBuildingInfo, resource_gathering::ResourceGatheringBuildingInfo,
+		tech_building::TechBuildingInfo,
 	},
 	footprint::BuildingFootprint,
 	prelude::Building,
 };
 
 #[derive(Asset, TypePath, Debug, Serialize, Deserialize)]
-pub struct BuildingAsset {
+pub struct BuildingAsset
+{
 	pub name: String,
 	pub description: String,
 	pub footprint: BuildingFootprint,
@@ -35,7 +38,9 @@ pub struct BuildingAsset {
 	pub components: Option<Vec<ComponentDefination>>,
 }
 
-impl BuildingAsset {
+impl BuildingAsset
+{
+	#[allow(unused)]
 	pub fn spawn(
 		&self,
 		pos: Vec3,
@@ -44,31 +49,38 @@ impl BuildingAsset {
 		commands: &mut Commands,
 		meshes: &Assets<GltfMesh>,
 		nodes: &Assets<GltfNode>,
-	) -> Option<Entity> {
+	) -> Option<Entity>
+	{
 		let base_node = &gltf.named_nodes[&self.base_mesh_path.clone().into_boxed_str()];
 		if let Some(node) = nodes.get(base_node.id()) {
 			if let Some(mesh_handle) = &node.mesh {
 				if let Some(gltf_mesh) = meshes.get(mesh_handle.id()) {
-					let (mesh, mat) = gltf_mesh.unpack();
+					if let Some(primitive) = gltf_mesh.primitives.first() {
-					let mut entity = commands.spawn((
+						let mesh = primitive.mesh.clone();
-						Mesh3d(mesh),
+						let mat = primitive
-						MeshMaterial3d(mat),
+							.material
-						Transform::from_translation(pos).with_rotation(rot),
+							.clone()
-						Building,
+							.expect(format!("Mesh '{}' does not have a meterial", primitive.name.as_str()).as_str());
-					));
+						let mut entity = commands.spawn((
-					entity.with_children(|b| {
+							Mesh3d(mesh),
-						for child in &node.children {
+							MeshMaterial3d(mat),
-							let child_node = nodes.get(child.id());
+							Transform::from_translation(pos).with_rotation(rot),
-							if child_node.is_none() {
+							Building,
-								continue;
+						));
+						entity.with_children(|b| {
+							for child in &node.children {
+								let child_node = nodes.get(child.id());
+								if child_node.is_none() {
+									continue;
+								}
+								self.process_node(child_node.unwrap(), meshes, nodes, b, &node.name);
 							}
-							self.process_node(child_node.unwrap(), meshes, nodes, b, &node.name);
+						});
+						if let Some(component) = self.get_component_def(&format!("/{0}", &node.name)) {
+							component.apply(&mut entity);
 						}
-					});
+						return Some(entity.id());
-					if let Some(component) = self.get_component_def(&format!("/{0}", &node.name)) {
-						component.apply(&mut entity);
 					}
-					return Some(entity.id());
 				}
 			}
 		}
@@ -80,33 +92,41 @@ impl BuildingAsset {
 		node: &GltfNode,
 		meshes: &Assets<GltfMesh>,
 		nodes: &Assets<GltfNode>,
-		commands: &mut ChildBuilder,
+		commands: &mut RelatedSpawnerCommands<ChildOf>,
 		parent: &String,
-	) -> Option<Entity> {
+	) -> Option<Entity>
+	{
 		let path = format!("{0}/{1}", parent, node.name);
 		if let Some(mesh) = &node.mesh {
 			if let Some(gltf_mesh) = meshes.get(mesh.id()) {
-				let (mesh, mat) = gltf_mesh.unpack();
+				if let Some(primitive) = gltf_mesh.primitives.first() {
-				let mut entity = commands.spawn((Mesh3d(mesh), MeshMaterial3d(mat), node.transform, Building));
+					let mesh = primitive.mesh.clone();
-				entity.with_children(|b| {
+					let mat = primitive
-					for child in &node.children {
+						.material
-						let child_node = nodes.get(child.id());
+						.clone()
-						if child_node.is_none() {
+						.expect(format!("Mesh '{}' does not have a meterial", primitive.name.as_str()).as_str());
-							continue;
+					let mut entity = commands.spawn((Mesh3d(mesh), MeshMaterial3d(mat), node.transform, Building));
+					entity.with_children(|b| {
+						for child in &node.children {
+							let child_node = nodes.get(child.id());
+							if child_node.is_none() {
+								continue;
+							}
+							self.process_node(child_node.unwrap(), meshes, nodes, b, &path);
 						}
-						self.process_node(child_node.unwrap(), meshes, nodes, b, &path);
+					});
+					if let Some(component) = self.get_component_def(&path) {
+						component.apply(&mut entity);
 					}
-				});
+					return Some(entity.id());
-				if let Some(component) = self.get_component_def(&path) {
-					component.apply(&mut entity);
 				}
-				return Some(entity.id());
 			}
 		}
 		return None;
 	}
 
-	fn get_component_def(&self, path: &String) -> Option<&ComponentDefination> {
+	fn get_component_def(&self, path: &String) -> Option<&ComponentDefination>
+	{
 		if let Some(components) = &self.components {
 			for c in components {
 				if c.path.ends_with(path) {
@@ -119,11 +139,13 @@ impl BuildingAsset {
 }
 
 #[derive(Serialize, Deserialize, Debug, TypePath)]
-pub enum BuildingType {
+pub enum BuildingType
-	Basic,
+{
+	Basic(BasicBuildingInfo),
 	Gathering(ResourceGatheringBuildingInfo),
 	FactoryBuildingInfo(FactoryBuildingInfo),
 	ResourceConduit(ResourceConduitInfo),
+	Tech(TechBuildingInfo),
 }
 
 create_asset_loader!(

game/buildings/src/build_queue.rs

@@ -1,15 +1,17 @@
-
 use bevy::prelude::Resource;
+use hex::prelude::*;
 use shared::building::BuildingIdentifier;
-use world_generation::hex_utils::HexCoord;
 
 #[derive(Resource)]
-pub struct BuildQueue {
+pub struct BuildQueue
+{
 	pub queue: Vec<QueueEntry>,
 }
 
-impl Default for BuildQueue {
+impl Default for BuildQueue
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self {
 			queue: Default::default(),
 		}
@@ -17,7 +19,8 @@ impl Default for BuildQueue {
 }
 
 #[derive(PartialEq, Eq)]
-pub struct QueueEntry {
+pub struct QueueEntry
+{
 	pub building: BuildingIdentifier,
 	pub pos: HexCoord,
 }

game/buildings/src/building_plugin.rs

@@ -1,26 +1,19 @@
-use std::f32::consts::E;
-
 use bevy::{
 	ecs::world::CommandQueue,
 	gltf::{GltfMesh, GltfNode},
 	prelude::*,
-	window::PrimaryWindow,
 };
 use bevy_asset_loader::loading_state::{
 	config::{ConfigureLoadingState, LoadingStateConfig},
 	LoadingStateAppExt,
 };
-use bevy_rapier3d::{parry::transformation::utils::transform, pipeline::QueryFilter, plugin::RapierContext};
 use shared::{
 	despawn::Despawn,
 	events::TileModifiedEvent,
 	resources::TileUnderCursor,
 	states::{AssetLoadState, GameplayState},
-	tags::MainCamera,
-};
-use world_generation::{
-	heightmap, hex_utils::HexCoord, map::map::Map, prelude::GenerationConfig, states::GeneratorState,
 };
+use world_generation::{map::map::Map, prelude::GenerationConfig, states::GeneratorState};
 
 use crate::{
 	assets::{
@@ -34,8 +27,10 @@ use crate::{
 
 pub struct BuildingPugin;
 
-impl Plugin for BuildingPugin {
+impl Plugin for BuildingPugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_resource(BuildQueue::default());
 		app.add_plugins(BuildingAssetPlugin);
 
@@ -46,7 +41,7 @@ impl Plugin for BuildingPugin {
 		app.add_systems(Update, init.run_if(in_state(AssetLoadState::Loading)));
 		app.add_systems(
 			Update,
-			hq_placement.run_if(in_state(GameplayState::PlaceHQ).and_then(in_state(GeneratorState::Idle))),
+			hq_placement.run_if(in_state(GameplayState::PlaceHQ).and(in_state(GeneratorState::Idle))),
 		);
 		app.add_systems(
 			PreUpdate,
@@ -62,12 +57,15 @@ impl Plugin for BuildingPugin {
 	}
 }
 
-fn prepare_building_map(mut commands: Commands, cfg: Res<GenerationConfig>) {
+fn prepare_building_map(mut commands: Commands, cfg: Res<GenerationConfig>)
+{
 	commands.insert_resource(BuildingMap::new(cfg.size));
 }
 
-fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>, cfg: Res<GenerationConfig>) {
+fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>, cfg: Res<GenerationConfig>)
-	for e in buildings.iter() {
+{
+	for e in buildings.iter()
+	{
 		commands.entity(e).despawn();
 	}
 	commands.insert_resource(BuildingMap::new(cfg.size));
@@ -76,7 +74,8 @@ fn regernerate(mut commands: Commands, buildings: Query<Entity, With<Building>>,
 #[derive(Resource)]
 struct IndicatorCube(Handle<Mesh>, Handle<StandardMaterial>);
 
-fn init(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>) {
+fn init(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>, mut materials: ResMut<Assets<StandardMaterial>>)
+{
 	let cube = Cuboid::from_size(Vec3::splat(1.));
 	let mesh_handle = meshes.add(cube);
 	let mat_handle = materials.add(Color::WHITE);
@@ -91,12 +90,15 @@ fn hq_placement(
 	indicator: Res<IndicatorCube>,
 	mut build_queue: ResMut<BuildQueue>,
 	mut next_state: ResMut<NextState<GameplayState>>,
-) {
+)
-	if let Some(contact) = tile_under_cursor.0 {
+{
+	if let Some(contact) = tile_under_cursor.0
+	{
 		let positions = map.hex_select(&contact.tile, 3, true, |pos, h, _| pos.to_world(h));
 		show_indicators(positions, &mut commands, &indicator);
 
-		if mouse.just_pressed(MouseButton::Left) {
+		if mouse.just_pressed(MouseButton::Left)
+		{
 			build_queue.queue.push(QueueEntry {
 				building: 0.into(),
 				pos: contact.tile,
@@ -107,8 +109,10 @@ fn hq_placement(
 	}
 }
 
-fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube) {
+fn show_indicators(positions: Vec<Vec3>, commands: &mut Commands, indicator: &IndicatorCube)
-	for p in positions {
+{
+	for p in positions
+	{
 		commands.spawn((
 			Mesh3d(indicator.0.clone()),
 			MeshMaterial3d(indicator.1.clone()),
@@ -128,13 +132,17 @@ fn process_build_queue(
 	gltf_nodes: Res<Assets<GltfNode>>,
 	mut building_map: ResMut<BuildingMap>,
 	heightmap: Res<Map>,
-) {
+)
-	for item in &queue.queue {
+{
+	for item in &queue.queue
+	{
 		let handle = &db.buildings[item.building.0];
-		if let Some(building) = building_assets.get(handle.id()) {
+		if let Some(building) = building_assets.get(handle.id())
+		{
 			let h = heightmap.sample_height(&item.pos);
 			println!("Spawning {} at {}", building.name, item.pos);
-			if let Some(gltf) = gltf_assets.get(building.prefab.id()) {
+			if let Some(gltf) = gltf_assets.get(building.prefab.id())
+			{
 				let e = building.spawn(
 					item.pos.to_world(h),
 					Quat::IDENTITY,
@@ -143,10 +151,13 @@ fn process_build_queue(
 					&gltf_meshes,
 					&gltf_nodes,
 				);
-				if let Some(b) = e {
+				if let Some(b) = e
+				{
 					building_map.add_building(BuildingEntry::new(item.pos, b));
 				}
-			} else {
+			}
+			else
+			{
 				warn!("Failed to spawn building");
 			}
 		}
@@ -155,20 +166,26 @@ fn process_build_queue(
 }
 
 fn update_building_heights(
-	mut tile_updates: EventReader<TileModifiedEvent>,
+	mut tile_updates: MessageReader<TileModifiedEvent>,
 	building_map: Res<BuildingMap>,
 	mut commands: Commands,
-) {
+)
-	for event in tile_updates.read() {
+{
-		match event {
+	for event in tile_updates.read()
-			TileModifiedEvent::HeightChanged(coord, new_height) => {
+	{
-				if let Some(building) = building_map.get_building(coord) {
+		match event
+		{
+			TileModifiedEvent::HeightChanged(coord, new_height) =>
+			{
+				if let Some(building) = building_map.get_building(coord)
+				{
 					let mut queue = CommandQueue::default();
 					let e = building.entity.clone();
 					let h = *new_height;
 					queue.push(move |world: &mut World| {
 						let mut emut = world.entity_mut(e);
-						if let Some(mut transform) = emut.get_mut::<Transform>() {
+						if let Some(mut transform) = emut.get_mut::<Transform>()
+						{
 							transform.translation.y = h;
 						}
 					});

game/buildings/src/buildings/basic_building.rs

@@ -1,3 +1,6 @@
 use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize, Debug)]
-pub struct BasicBuildingInfo {}
+pub struct BasicBuildingInfo
+{
+	health: u32,
+}

game/buildings/src/buildings_map.rs

@@ -1,21 +1,26 @@
 use bevy::prelude::*;
-use world_generation::{hex_utils::HexCoord, prelude::Chunk};
+use hex::prelude::*;
 
 #[derive(Resource)]
-pub struct BuildingMap {
+pub struct BuildingMap
+{
 	pub chunks: Vec<BuildingChunk>,
 	pub size: UVec2,
 }
 
-impl BuildingMap {
+impl BuildingMap
-	pub fn new(size: UVec2) -> Self {
+{
+	pub fn new(size: UVec2) -> Self
+	{
 		let mut db = BuildingMap {
 			size,
 			chunks: Vec::with_capacity(size.length_squared() as usize),
 		};
 
-		for y in 0..size.y as i32 {
+		for y in 0..size.y as i32
-			for x in 0..size.x as i32 {
+		{
+			for x in 0..size.x as i32
+			{
 				let offset = IVec2::new(x, y);
 				let index = (x + y * size.x as i32) as usize;
 				db.chunks.push(BuildingChunk::new(offset, index));
@@ -25,7 +30,8 @@ impl BuildingMap {
 		return db;
 	}
 
-	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Vec<&BuildingEntry> {
+	pub fn get_buildings_in_range(&self, coord: &HexCoord, radius: usize) -> Vec<&BuildingEntry>
+	{
 		assert!(radius != 0, "Radius cannot be zero");
 
 		let w = self.size.x as usize * Chunk::SIZE;
@@ -34,10 +40,13 @@ impl BuildingMap {
 		return self.get_buildings_in_coords(coords);
 	}
 
-	pub fn get_buildings_in_coords(&self, coords: Vec<HexCoord>) -> Vec<&BuildingEntry> {
+	pub fn get_buildings_in_coords(&self, coords: Vec<HexCoord>) -> Vec<&BuildingEntry>
+	{
 		let mut result = Vec::new();
-		for coord in &coords {
+		for coord in &coords
-			if let Some(buidling) = self.get_building(coord) {
+		{
+			if let Some(buidling) = self.get_building(coord)
+			{
 				result.push(buidling);
 			}
 		}
@@ -45,25 +54,30 @@ impl BuildingMap {
 		return result;
 	}
 
-	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
+	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry>
+	{
 		let chunk = &self.chunks[coord.to_chunk_index(self.size.x as usize)];
 		return chunk.get_building(coord);
 	}
 
-	pub fn add_building(&mut self, entry: BuildingEntry) {
+	pub fn add_building(&mut self, entry: BuildingEntry)
+	{
 		let chunk = &mut self.chunks[entry.coord.to_chunk_index(self.size.x as usize)];
 		chunk.add_building(entry);
 	}
 }
 
-pub struct BuildingChunk {
+pub struct BuildingChunk
+{
 	pub entries: Vec<BuildingEntry>,
 	pub index: usize,
 	pub offset: IVec2,
 }
 
-impl BuildingChunk {
+impl BuildingChunk
-	pub fn new(offset: IVec2, index: usize) -> Self {
+{
+	pub fn new(offset: IVec2, index: usize) -> Self
+	{
 		return BuildingChunk {
 			entries: Vec::new(),
 			index,
@@ -71,16 +85,19 @@ impl BuildingChunk {
 		};
 	}
 
-	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry> {
+	pub fn get_building(&self, coord: &HexCoord) -> Option<&BuildingEntry>
+	{
 		return self.entries.iter().find(|b| &b.coord == coord);
 	}
 
-	pub fn add_building(&mut self, entry: BuildingEntry) {
+	pub fn add_building(&mut self, entry: BuildingEntry)
+	{
 		self.entries.push(entry);
 	}
 }
 
-pub struct BuildingEntry {
+pub struct BuildingEntry
+{
 	pub coord: HexCoord,
 	pub entity: Entity,
 	pub is_main: bool,
@@ -89,8 +106,10 @@ pub struct BuildingEntry {
 	pub child_entities: Option<Vec<Entity>>,
 }
 
-impl BuildingEntry {
+impl BuildingEntry
-	pub fn new(coord: HexCoord, entity: Entity) -> Self {
+{
+	pub fn new(coord: HexCoord, entity: Entity) -> Self
+	{
 		return BuildingEntry {
 			coord,
 			entity,
@@ -101,7 +120,8 @@ impl BuildingEntry {
 		};
 	}
 
-	pub fn new_with_children(coord: HexCoord, entity: Entity, children: Vec<Entity>) -> BuildingEntry {
+	pub fn new_with_children(coord: HexCoord, entity: Entity, children: Vec<Entity>) -> BuildingEntry
+	{
 		return BuildingEntry {
 			coord,
 			entity,
@@ -112,7 +132,8 @@ impl BuildingEntry {
 		};
 	}
 
-	pub fn new_with_parent(coord: HexCoord, entity: Entity, main: Entity) -> BuildingEntry {
+	pub fn new_with_parent(coord: HexCoord, entity: Entity, main: Entity) -> BuildingEntry
+	{
 		return BuildingEntry {
 			coord,
 			entity,

game/buildings/src/footprint.rs

@@ -1,32 +1,39 @@
 use bevy::math::{IVec2, Vec3Swizzles};
+use hex::prelude::*;
 use serde::{Deserialize, Serialize};
-use world_generation::hex_utils::HexCoord;
+use shared::coords::CoordsCollection;
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct BuildingFootprint {
+pub struct BuildingFootprint
+{
 	pub footprint: Vec<IVec2>,
 }
 
-impl BuildingFootprint {
+impl BuildingFootprint
-	pub fn get_footprint(&self, center: &HexCoord) -> Vec<HexCoord> {
+{
-		let c = center.hex.xy();
+	pub fn get_footprint(&self, position: &HexCoord) -> CoordsCollection
-		return self.footprint.iter().map(|p| HexCoord::from_hex(*p + c)).collect();
+	{
+		CoordsCollection::from_points(self.footprint.clone()).with_translation(position)
 	}
 
-	pub fn get_footprint_rotated(&self, center: &HexCoord, rotation: i32) -> Vec<HexCoord> {
+	pub fn get_neighbors(&self, position: &HexCoord) -> CoordsCollection
-		let c = center.hex.xy();
+	{
-		return self
+		let n_points: Vec<IVec2> = self
 			.footprint
 			.iter()
-			.map(|p| HexCoord::from_hex(*p + c).rotate_around(center, rotation))
+			.flat_map(|p| HexCoord::from_axial(*p).get_neighbors())
+			.map(|c| c.hex.xy())
+			.filter(|p| !self.footprint.contains(p))
 			.collect();
-	}
+		let mut out_points: Vec<IVec2> = Vec::with_capacity(n_points.len());
-
+		for p in n_points
-	pub fn get_neighbors(&self, center: &HexCoord) -> Vec<HexCoord> {
+		{
-		todo!()
+			if out_points.contains(&p)
-	}
+			{
-
+				continue;
-	pub fn get_neighbors_rotated(&self, center: &HexCoord, rotation: i32) -> Vec<HexCoord> {
+			}
-		todo!();
+			out_points.push(p);
+		}
+		return CoordsCollection::from_points(out_points).with_translation(position);
 	}
 }

game/main/Cargo.toml

@@ -7,29 +7,32 @@ build = "build.rs"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = { version = "0.15.1", features = ["file_watcher"] }
+bevy = { version = "0.18.0", features = ["file_watcher"] }
-bevy-inspector-egui = "0.28.1"
+bevy-inspector-egui = "0.36.0"
 # iyes_perf_ui = "0.3.0"
-noise = "0.8.2"
+noise = "0.9.0"
 world_generation = { path = "../../engine/world_generation" }
-bevy_rapier3d = { version = "0.28.0", features = [
+bevy_rapier3d = { version = "0.33.0", features = [
 	"simd-stable",
 	"parallel",
 	"debug-render-3d",
 ] }
-rayon = "1.10.0"
+rayon = "1.11.0"
 buildings = { path = "../buildings" }
 units = { path = "../units" }
 shared = { path = "../shared" }
-bevy_asset_loader = { version = "0.22.0", features = [
+bevy_asset_loader = { version = "0.25.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
-ron = "0.8.1"
+ron = "0.12.0"
-image = "0.25.2"
+image = "0.25.9"
+hex = { path = "../../engine/hex" }
+
 # bevy_lunex = "0.2.4"
 
 [features]
+editor = []
 tracing = [
 	"bevy/trace_tracy",
 	"world_generation/tracing",

game/main/src/camera_system/camera_plugin.rs

@@ -1,11 +1,12 @@
-use bevy::core_pipeline::experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin, TemporalAntiAliasing};
+use bevy::anti_alias::taa::TemporalAntiAliasing;
+use bevy::camera::visibility::RenderLayers;
 use bevy::core_pipeline::prepass::DepthPrepass;
 use bevy::input::mouse::{MouseMotion, MouseScrollUnit, MouseWheel};
 use bevy::prelude::*;
-use bevy::window::{CursorGrabMode, PrimaryWindow};
+use bevy::window::{CursorGrabMode, CursorOptions, PrimaryWindow};
+use hex::prelude::*;
 use shared::sets::GameplaySet;
 use shared::tags::MainCamera;
-use world_generation::hex_utils::HexCoord;
 use world_generation::prelude::Map;
 use world_generation::states::GeneratorState;
 
@@ -13,8 +14,10 @@ use super::components::*;
 
 pub struct PhosCameraPlugin;
 
-impl Plugin for PhosCameraPlugin {
+impl Plugin for PhosCameraPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.register_type::<PhosCamera>();
 		app.register_type::<PhosOrbitCamera>();
 
@@ -23,17 +26,12 @@ impl Plugin for PhosCameraPlugin {
 		app.add_systems(Update, orbit_camera_upate.in_set(GameplaySet));
 
 		app.add_systems(Update, init_bounds.run_if(in_state(GeneratorState::SpawnMap)));
-
-		app.add_plugins(TemporalAntiAliasPlugin);
 	}
 }
 
-fn init_bounds(
+fn init_bounds(mut commands: Commands, cam: Single<(&mut Transform, Entity), With<PhosCamera>>, heightmap: Res<Map>)
-	mut commands: Commands,
+{
-	mut cam: Query<(&mut Transform, Entity), With<PhosCamera>>,
+	let (mut cam_t, cam_entity) = cam.into_inner();
-	heightmap: Res<Map>,
-) {
-	let (mut cam_t, cam_entity) = cam.single_mut();
 	cam_t.translation = heightmap.get_center();
 	commands
 		.entity(cam_entity)
@@ -44,7 +42,8 @@ fn init_bounds(
 		});
 }
 
-fn setup(mut commands: Commands) {
+fn setup(mut commands: Commands)
+{
 	commands
 		.spawn((
 			Camera3d::default(),
@@ -55,25 +54,23 @@ fn setup(mut commands: Commands) {
 			PhosOrbitCamera::default(),
 			TemporalAntiAliasing::default(),
 		))
-		.insert(Msaa::Off);
+		.insert(Msaa::Off)
-	// .insert(RenderLayers::layer(0))
+		.insert(RenderLayers::default());
-
-	// *msaa = Msaa::Off;
 }
 
 fn orbit_camera_upate(
-	mut cam_query: Query<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
+	cam_query: Single<(&mut Transform, &PhosCamera, &mut PhosOrbitCamera, &CameraBounds)>,
-	mut wheel: EventReader<MouseWheel>,
+	mut wheel: MessageReader<MouseWheel>,
-	mut mouse_motion: EventReader<MouseMotion>,
+	mut mouse_motion: MessageReader<MouseMotion>,
 	mouse: Res<ButtonInput<MouseButton>>,
-	mut window_query: Query<&mut Window, With<PrimaryWindow>>,
+	mut cursor_options: Single<&mut CursorOptions, With<PrimaryWindow>>,
 	key: Res<ButtonInput<KeyCode>>,
 	time: Res<Time>,
 	map: Res<Map>,
 	#[cfg(debug_assertions)] mut gizmos: Gizmos,
-) {
+)
-	let (mut transform, config, mut orbit, bounds) = cam_query.single_mut();
+{
-	let mut window = window_query.single_mut();
+	let (mut transform, config, mut orbit, bounds) = cam_query.into_inner();
 
 	let target = orbit.target;
 	let mut cam_pos = target;
@@ -81,9 +78,11 @@ fn orbit_camera_upate(
 	//Apply Camera Dist
 	cam_pos -= orbit.forward * orbit.distance;
 
-	if mouse.pressed(MouseButton::Middle) {
+	if mouse.pressed(MouseButton::Middle)
+	{
 		let mut orbit_move = Vec2::ZERO;
-		for e in mouse_motion.read() {
+		for e in mouse_motion.read()
+		{
 			orbit_move += e.delta;
 		}
 		orbit_move *= config.pan_speed * time.delta_secs() * -1.0;
@@ -93,41 +92,56 @@ fn orbit_camera_upate(
 		orbit.forward = rot_x * rot_y * orbit.forward;
 		// orbit.forward.y = orbit.forward.y.clamp(-0.9, 0.0);
 		orbit.forward = orbit.forward.normalize();
-		window.cursor_options.grab_mode = CursorGrabMode::Locked;
+		cursor_options.grab_mode = CursorGrabMode::Locked;
-		window.cursor_options.visible = false;
+		cursor_options.visible = false;
-	} else {
-		window.cursor_options.grab_mode = CursorGrabMode::None;
-		window.cursor_options.visible = true;
 	}
-	if key.pressed(KeyCode::KeyE) {
+	else
+	{
+		cursor_options.grab_mode = CursorGrabMode::None;
+		cursor_options.visible = true;
+	}
+	if key.pressed(KeyCode::KeyE)
+	{
 		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(config.speed) * time.delta_secs());
 		orbit.forward = rot * orbit.forward;
-	} else if key.pressed(KeyCode::KeyQ) {
+	}
+	else if key.pressed(KeyCode::KeyQ)
+	{
 		let rot = Quat::from_axis_angle(Vec3::Y, f32::to_radians(-config.speed) * time.delta_secs());
 		orbit.forward = rot * orbit.forward;
 	}
 
 	let mut cam_move = Vec3::ZERO;
 
-	if key.pressed(KeyCode::KeyA) {
+	if key.pressed(KeyCode::KeyA)
+	{
 		cam_move.x = 1.;
-	} else if key.pressed(KeyCode::KeyD) {
+	}
+	else if key.pressed(KeyCode::KeyD)
+	{
 		cam_move.x = -1.;
 	}
 
-	if key.pressed(KeyCode::KeyW) {
+	if key.pressed(KeyCode::KeyW)
+	{
 		cam_move.z = 1.;
-	} else if key.pressed(KeyCode::KeyS) {
+	}
+	else if key.pressed(KeyCode::KeyS)
+	{
 		cam_move.z = -1.;
 	}
 
-	let move_speed = if key.pressed(KeyCode::ShiftLeft) {
+	let move_speed = if key.pressed(KeyCode::ShiftLeft)
+	{
 		config.speed * 2.0
-	} else {
+	}
+	else
+	{
 		config.speed
 	};
 
-	if cam_move != Vec3::ZERO {
+	if cam_move != Vec3::ZERO
+	{
 		cam_move = cam_move.normalize();
 		let move_fwd = Vec3::new(orbit.forward.x, 0., orbit.forward.z).normalize();
 		let move_rot = Quat::from_rotation_arc(Vec3::NEG_Z, move_fwd);
@@ -144,8 +158,10 @@ fn orbit_camera_upate(
 	}
 
 	let mut scroll = 0.0;
-	for e in wheel.read() {
+	for e in wheel.read()
-		match e.unit {
+	{
+		match e.unit
+		{
 			MouseScrollUnit::Line => scroll += e.y * 5.,
 			MouseScrollUnit::Pixel => scroll += e.y,
 		}
@@ -167,23 +183,31 @@ fn orbit_camera_upate(
 	transform.look_at(target, Vec3::Y);
 }
 
-fn sample_ground(pos: Vec3, heightmap: &Map) -> f32 {
+fn sample_ground(pos: Vec3, heightmap: &Map) -> f32
+{
 	let tile_under = HexCoord::from_world_pos(pos);
 	let neighbors = heightmap.get_neighbors(&tile_under);
-	let mut ground_height = if heightmap.is_in_bounds(&tile_under) {
+	let mut ground_height = if heightmap.is_in_bounds(&tile_under)
+	{
 		heightmap.sample_height(&tile_under)
-	} else {
+	}
+	else
+	{
 		heightmap.sealevel
 	};
 
-	for n in neighbors {
+	for n in neighbors
-		if let Some(h) = n {
+	{
-			if h > ground_height {
+		if let Some(h) = n
+		{
+			if h > ground_height
+			{
 				ground_height = h;
 			}
 		}
 	}
-	if ground_height < heightmap.sealevel {
+	if ground_height < heightmap.sealevel
+	{
 		ground_height = heightmap.sealevel;
 	}
 	return ground_height;

game/main/src/camera_system/components.rs

@@ -1,10 +1,11 @@
-use bevy::{math::Direction3d, prelude::*};
+use bevy::prelude::*;
+use hex::prelude::*;
 use rayon::str;
-use world_generation::{hex_utils::SHORT_DIAGONAL, prelude::Chunk};
 
 #[derive(Component, Reflect)]
 #[reflect(Component)]
-pub struct PhosCamera {
+pub struct PhosCamera
+{
 	pub min_height: f32,
 	pub max_height: f32,
 	pub speed: f32,
@@ -14,8 +15,10 @@ pub struct PhosCamera {
 	pub max_angle: f32,
 }
 
-impl Default for PhosCamera {
+impl Default for PhosCamera
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self {
 			min_height: 10.,
 			max_height: 420.,
@@ -28,14 +31,17 @@ impl Default for PhosCamera {
 	}
 }
 #[derive(Component, Reflect)]
-pub struct PhosOrbitCamera {
+pub struct PhosOrbitCamera
+{
 	pub target: Vec3,
 	pub distance: f32,
 	pub forward: Vec3,
 }
 
-impl Default for PhosOrbitCamera {
+impl Default for PhosOrbitCamera
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self {
 			target: Default::default(),
 			distance: 40.0,
@@ -45,13 +51,16 @@ impl Default for PhosOrbitCamera {
 }
 
 #[derive(Component, Default)]
-pub struct CameraBounds {
+pub struct CameraBounds
+{
 	pub min: Vec2,
 	pub max: Vec2,
 }
 
-impl CameraBounds {
+impl CameraBounds
-	pub fn from_size(world_size: Vec2) -> Self {
+{
+	pub fn from_size(world_size: Vec2) -> Self
+	{
 		let padding = Chunk::WORLD_SIZE;
 		return Self {
 			min: Vec2::ZERO - padding,

game/main/src/main.rs

@@ -1,9 +1,10 @@
-use std::env;
-
 use bevy::image::{ImageAddressMode, ImageFilterMode, ImageSamplerDescriptor};
 use bevy::pbr::wireframe::WireframePlugin;
 use bevy::prelude::*;
 use bevy::window::PresentMode;
+#[cfg(debug_assertions)]
+use bevy::window::WindowResolution;
+use bevy_inspector_egui::bevy_egui::EguiPlugin;
 use bevy_inspector_egui::quick::WorldInspectorPlugin;
 use phos::PhosGamePlugin;
 
@@ -15,7 +16,8 @@ mod shader_extensions;
 mod ui;
 mod utlis;
 
-fn main() {
+fn main()
+{
 	App::new()
 		.add_plugins((
 			DefaultPlugins
@@ -24,7 +26,7 @@ fn main() {
 						title: "Phos".into(),
 						name: Some("phos".into()),
 						#[cfg(debug_assertions)]
-						resolution: (1920., 1080.).into(),
+						resolution: WindowResolution::new(1920, 1080),
 						present_mode: PresentMode::AutoNoVsync,
 						#[cfg(not(debug_assertions))]
 						mode: bevy::window::WindowMode::BorderlessFullscreen,
@@ -45,8 +47,9 @@ fn main() {
 					watch_for_changes_override: Some(true),
 					..Default::default()
 				}),
+			EguiPlugin::default(),
 			WorldInspectorPlugin::new(),
-			WireframePlugin,
+			WireframePlugin::default(),
 			PhosGamePlugin,
 		))
 		.run();

game/main/src/map_rendering/chunk_rebuild.rs

@@ -1,7 +1,6 @@
 use bevy::ecs::world::CommandQueue;
 use bevy::prelude::*;
 use bevy::tasks::*;
-use bevy::utils::futures;
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::geometry::TriMeshFlags;
 use shared::events::ChunkModifiedEvent;
@@ -10,6 +9,7 @@ use world_generation::prelude::Map;
 use world_generation::states::GeneratorState;
 
 use crate::prelude::RebuildChunk;
+use crate::prelude::WaterMesh;
 use crate::{
 	prelude::{PhosChunk, PhosChunkRegistry},
 	utlis::chunk_utils::prepare_chunk_mesh,
@@ -17,11 +17,13 @@ use crate::{
 
 pub struct ChunkRebuildPlugin;
 
-impl Plugin for ChunkRebuildPlugin {
+impl Plugin for ChunkRebuildPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<PhosChunkRegistry>();
-		app.add_event::<ChunkModifiedEvent>();
+		app.add_message::<ChunkModifiedEvent>();
-		app.add_event::<TileModifiedEvent>();
+		app.add_message::<TileModifiedEvent>();
 		app.add_systems(PreUpdate, chunk_rebuilder.run_if(in_state(GeneratorState::Idle)));
 		app.add_systems(PostUpdate, collider_task_resolver);
 	}
@@ -31,11 +33,13 @@ fn chunk_rebuilder(
 	mut commands: Commands,
 	chunk_query: Query<(Entity, &PhosChunk), (With<RebuildChunk>, Without<ChunkRebuildTask>)>,
 	heightmap: Res<Map>,
-) {
+)
+{
 	let pool = AsyncComputeTaskPool::get();
 	let map_size = UVec2::new(heightmap.width as u32, heightmap.height as u32);
 
-	for (chunk_entity, idx) in &chunk_query {
+	for (chunk_entity, idx) in &chunk_query
+	{
 		#[cfg(feature = "tracing")]
 		let _spawn_span = info_span!("Rebuild Chunk").entered();
 		info!("Rebuilding Chunk");
@@ -55,14 +59,15 @@ fn chunk_rebuilder(
 				collider_data.0,
 				collider_data.1,
 				TriMeshFlags::DELETE_DUPLICATE_TRIANGLES,
-			);
+			)
+			.expect("Failed to build chunk mesh");
 			#[cfg(feature = "tracing")]
 			drop(trimesh_span);
 			queue.push(move |world: &mut World| {
 				world.entity_mut(chunk_entity).insert(c).remove::<ChunkRebuildTask>();
 			});
 
-			return (queue, mesh);
+			return (queue, mesh, water_mesh);
 		});
 
 		commands
@@ -73,19 +78,28 @@ fn chunk_rebuilder(
 }
 
 fn collider_task_resolver(
-	mut chunks: Query<(&mut ChunkRebuildTask, &Mesh3d), With<PhosChunk>>,
+	mut chunks: Query<(&mut ChunkRebuildTask, &Mesh3d, &WaterMesh), With<PhosChunk>>,
 	mut commands: Commands,
 	mut meshes: ResMut<Assets<Mesh>>,
-) {
+)
-	for (mut task, mesh_handle) in &mut chunks {
+{
-		if let Some((mut c, mesh)) = futures::check_ready(&mut task.task) {
+	for (mut task, mesh_handle, water_mesh_handle) in &mut chunks
+	{
+		if let Some((mut c, chunk_mesh, water_mesh)) = futures::check_ready(&mut task.task)
+		{
 			commands.append(&mut c);
-			meshes.insert(mesh_handle.id(), mesh);
+			meshes
+				.insert(mesh_handle.id(), chunk_mesh)
+				.expect("Failed to update chunk mesh");
+			meshes
+				.insert(water_mesh_handle.0, water_mesh)
+				.expect("Failed to update chink water mesh");
 		}
 	}
 }
 
 #[derive(Component)]
-struct ChunkRebuildTask {
+struct ChunkRebuildTask
-	pub task: Task<(CommandQueue, Mesh)>,
+{
+	pub task: Task<(CommandQueue, Mesh, Mesh)>,
 }

game/main/src/map_rendering/map_init.rs

@@ -1,20 +1,17 @@
 #[cfg(feature = "tracing")]
 use bevy::log::*;
-use bevy::{
+use bevy::{light::NotShadowCaster, pbr::ExtendedMaterial, prelude::*};
-	pbr::{ExtendedMaterial, NotShadowCaster},
-	prelude::*,
-	render::render_resource::{ColorTargetState, FragmentState, RenderPipelineDescriptor},
-};
 use bevy_asset_loader::prelude::*;
 
 use bevy_inspector_egui::quick::ResourceInspectorPlugin;
+use hex::prelude::*;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use shared::states::{AssetLoadState, GameplayState, MenuState};
+
 use world_generation::{
 	biome_asset::{BiomeAsset, BiomeAssetPlugin},
 	biome_painter::*,
 	heightmap::generate_heightmap,
-	hex_utils::{offset_to_index, SHORT_DIAGONAL},
 	map::biome_map::BiomeMap,
 	prelude::*,
 	tile_manager::*,
@@ -22,7 +19,7 @@ use world_generation::{
 };
 
 use crate::{
-	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry},
+	prelude::{PhosAssets, PhosChunk, PhosChunkRegistry, WaterMesh},
 	shader_extensions::{
 		chunk_material::ChunkMaterial,
 		water_material::{WaterMaterial, WaterSettings},
@@ -34,8 +31,10 @@ use super::{chunk_rebuild::ChunkRebuildPlugin, render_distance_system::RenderDis
 
 pub struct MapInitPlugin;
 
-impl Plugin for MapInitPlugin {
+impl Plugin for MapInitPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_state(GeneratorState::Startup);
 		app.insert_state(AssetLoadState::Loading);
 
@@ -51,10 +50,7 @@ impl Plugin for MapInitPlugin {
 			ChunkRebuildPlugin,
 			// TerraFormingTestPlugin,
 			MaterialPlugin::<ExtendedMaterial<StandardMaterial, ChunkMaterial>>::default(),
-			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>> {
+			MaterialPlugin::<ExtendedMaterial<StandardMaterial, WaterMaterial>>::default(),
-				prepass_enabled: false,
-				..Default::default()
-			},
 		));
 
 		app.configure_loading_state(
@@ -78,7 +74,7 @@ impl Plugin for MapInitPlugin {
 		app.add_systems(Update, despawn_map.run_if(in_state(GeneratorState::Regenerate)));
 		app.add_systems(
 			Update,
-			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and_then(in_state(GeneratorState::SpawnMap))),
+			spawn_map.run_if(in_state(AssetLoadState::LoadComplete).and(in_state(GeneratorState::SpawnMap))),
 		);
 
 		app.insert_resource(TileManager::default());
@@ -88,7 +84,8 @@ impl Plugin for MapInitPlugin {
 fn setup_materials(
 	mut phos_assets: ResMut<PhosAssets>,
 	mut water_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, WaterMaterial>>>,
-) {
+)
+{
 	let water_material = water_materials.add(ExtendedMaterial {
 		base: StandardMaterial {
 			base_color: Color::srgb(0., 0.878, 1.),
@@ -114,7 +111,8 @@ fn finalize_biome_painter(
 	mut next_generator_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainterAsset>,
 	biomes: Res<Assets<BiomeAsset>>,
-) {
+)
+{
 	let painter = biome_painter.build(&biomes);
 	commands.insert_resource(painter);
 	next_generator_state.set(GeneratorState::GenerateHeightmap);
@@ -125,11 +123,14 @@ fn finalize_texture(
 	mut images: ResMut<Assets<Image>>,
 	mut chunk_materials: ResMut<Assets<ExtendedMaterial<StandardMaterial, ChunkMaterial>>>,
 	mut next_load_state: ResMut<NextState<AssetLoadState>>,
-) {
+)
+{
 	let image = images.get_mut(atlas.handle.id()).unwrap();
 
 	let array_layers = image.height() / image.width();
-	image.reinterpret_stacked_2d_as_array(array_layers);
+	image
+		.reinterpret_stacked_2d_as_array(array_layers)
+		.expect("Failed to reinterpret as array");
 
 	let chunk_material = chunk_materials.add(ExtendedMaterial {
 		base: StandardMaterial::default(),
@@ -146,7 +147,8 @@ fn create_heightmap(
 	mut commands: Commands,
 	mut next_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainter>,
-) {
+)
+{
 	let config = GenerationConfig {
 		biome_blend: 32,
 		biome_dither: 10.,
@@ -217,7 +219,8 @@ fn spawn_map(
 	mut game_state: ResMut<NextState<MenuState>>,
 	mut gameplay_state: ResMut<NextState<GameplayState>>,
 	biome_painter: Res<BiomePainter>,
-) {
+)
+{
 	paint_map(&mut heightmap, &biome_painter, &tile_assets, &tile_mappers);
 
 	//Prepare Mesh Data
@@ -248,21 +251,24 @@ fn spawn_map(
 			0.,
 			(Chunk::SIZE / 2) as f32 * 1.5,
 		);
-		for (chunk_mesh, water_mesh, collider, pos, index) in chunk_meshes {
+		for (chunk_mesh, water_mesh, collider, pos, index) in chunk_meshes
+		{
 			// let mesh_handle = meshes.a
+			let water_mesh_handle = meshes.add(water_mesh);
 			let chunk = commands
 				.spawn((
 					Mesh3d(meshes.add(chunk_mesh)),
 					MeshMaterial3d(atlas.chunk_material_handle.clone()),
 					Transform::from_translation(pos),
 					PhosChunk::new(index),
+					WaterMesh(water_mesh_handle.id()),
 					RenderDistanceVisibility::default().with_offset(visibility_offset),
 					collider,
 				))
 				.id();
 			let water = commands
 				.spawn((
-					Mesh3d(meshes.add(water_mesh)),
+					Mesh3d(water_mesh_handle),
 					MeshMaterial3d(atlas.water_material.clone()),
 					Transform::from_translation(pos),
 					PhosChunk::new(index),
@@ -277,7 +283,8 @@ fn spawn_map(
 
 	commands.insert_resource(registry);
 	generator_state.set(GeneratorState::Idle);
-	if cur_game_state.get() != &MenuState::InGame {
+	if cur_game_state.get() != &MenuState::InGame
+	{
 		game_state.set(MenuState::InGame);
 		gameplay_state.set(GameplayState::PlaceHQ);
 	}
@@ -291,8 +298,10 @@ fn despawn_map(
 	chunks: Query<Entity, With<PhosChunk>>,
 	mut next_state: ResMut<NextState<GeneratorState>>,
 	biome_painter: Res<BiomePainter>,
-) {
+)
-	for chunk in chunks.iter() {
+{
+	for chunk in chunks.iter()
+	{
 		commands.entity(chunk).despawn();
 	}
 

game/main/src/map_rendering/prelude.rs

@@ -1,2 +1 @@
-use bevy::prelude::*;
+
-use world_generation::biome_painter::BiomePainterAsset;

game/main/src/map_rendering/render_distance_system.rs

@@ -1,12 +1,12 @@
 use bevy::prelude::*;
 use shared::tags::MainCamera;
 
-use crate::camera_system::components::PhosCamera;
-
 pub struct RenderDistancePlugin;
 
-impl Plugin for RenderDistancePlugin {
+impl Plugin for RenderDistancePlugin
-	fn build(&self, app: &mut bevy::prelude::App) {
+{
+	fn build(&self, app: &mut bevy::prelude::App)
+	{
 		app.register_type::<RenderDistanceSettings>();
 		app.add_systems(PostUpdate, render_distance_system)
 			.insert_resource(RenderDistanceSettings::default());
@@ -15,54 +15,68 @@ impl Plugin for RenderDistancePlugin {
 
 #[derive(Resource, Reflect)]
 #[reflect(Resource)]
-pub struct RenderDistanceSettings {
+pub struct RenderDistanceSettings
+{
 	pub render_distance: f32,
 }
 
-impl RenderDistanceSettings {
+impl RenderDistanceSettings
-	pub fn new(distance: f32) -> Self {
+{
+	pub fn new(distance: f32) -> Self
+	{
 		return Self {
 			render_distance: distance,
 		};
 	}
 }
 
-impl Default for RenderDistanceSettings {
+impl Default for RenderDistanceSettings
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self::new(500.)
 	}
 }
 
 #[derive(Component)]
-pub struct RenderDistanceVisibility {
+pub struct RenderDistanceVisibility
+{
 	pub offset: Vec3,
 }
 
-impl RenderDistanceVisibility {
+impl RenderDistanceVisibility
-	pub fn with_offset(mut self, offset: Vec3) -> Self {
+{
+	pub fn with_offset(mut self, offset: Vec3) -> Self
+	{
 		self.offset = offset;
 		return self;
 	}
 }
 
-impl Default for RenderDistanceVisibility {
+impl Default for RenderDistanceVisibility
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self { offset: Vec3::ZERO }
 	}
 }
 
 fn render_distance_system(
 	mut objects: Query<(&Transform, &mut Visibility, &RenderDistanceVisibility)>,
-	camera_query: Query<&Transform, With<MainCamera>>,
+	camera: Single<&Transform, With<MainCamera>>,
 	settings: Res<RenderDistanceSettings>,
-) {
+)
-	let camera = camera_query.single();
+{
 	let cam_pos = Vec3::new(camera.translation.x, 0.0, camera.translation.z);
-	for (t, mut vis, r) in objects.iter_mut() {
+	for (t, mut vis, r) in objects.iter_mut()
+	{
 		let dist = (cam_pos - (t.translation + r.offset)).length();
-		if settings.render_distance < dist {
+		if settings.render_distance < dist
+		{
 			*vis = Visibility::Hidden;
-		} else {
+		}
+		else
+		{
 			*vis = Visibility::Visible;
 		}
 	}

game/main/src/map_rendering/terraforming_test.rs

@@ -1,21 +1,20 @@
-use bevy::{prelude::*, utils::hashbrown::HashSet, window::PrimaryWindow};
+use bevy::{platform::collections::HashSet, prelude::*};
-use bevy_rapier3d::{pipeline::QueryFilter, plugin::RapierContext};
 use shared::{
 	events::{ChunkModifiedEvent, TileModifiedEvent},
 	resources::TileUnderCursor,
 	states::GameplayState,
 };
-use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
+use world_generation::{prelude::Map, states::GeneratorState};
 
-use crate::{
+use crate::prelude::{PhosChunkRegistry, RebuildChunk};
-	camera_system::components::PhosCamera,
-	prelude::{PhosChunkRegistry, RebuildChunk},
-};
 
+#[allow(dead_code)]
 pub struct TerraFormingTestPlugin;
 
-impl Plugin for TerraFormingTestPlugin {
+impl Plugin for TerraFormingTestPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.add_systems(
 			Update,
 			deform
@@ -25,39 +24,48 @@ impl Plugin for TerraFormingTestPlugin {
 	}
 }
 
+#[allow(dead_code)]
 fn deform(
 	mut commands: Commands,
 	mouse: Res<ButtonInput<MouseButton>>,
 	mut heightmap: ResMut<Map>,
 	chunks: Res<PhosChunkRegistry>,
 	tile_under_cursor: Res<TileUnderCursor>,
-	mut chunk_modified: EventWriter<ChunkModifiedEvent>,
+	mut chunk_modified: MessageWriter<ChunkModifiedEvent>,
-	mut tile_modified: EventWriter<TileModifiedEvent>,
+	mut tile_modified: MessageWriter<TileModifiedEvent>,
-) {
+)
+{
 	let mut multi = 0.;
-	if mouse.just_pressed(MouseButton::Left) {
+	if mouse.just_pressed(MouseButton::Left)
+	{
 		multi = 1.;
-	} else if mouse.just_pressed(MouseButton::Right) {
+	}
+	else if mouse.just_pressed(MouseButton::Right)
+	{
 		multi = -1.;
 	}
 
-	if multi == 0. {
+	if multi == 0.
+	{
 		return;
 	}
 
-	if let Some(contact) = tile_under_cursor.0 {
+	if let Some(contact) = tile_under_cursor.0
+	{
 		#[cfg(feature = "tracing")]
 		let span = info_span!("Deform Mesh").entered();
 		let modified_tiles = heightmap.create_crater(&contact.tile, 5, 5. * multi);
 		let mut chunk_set: HashSet<usize> = HashSet::new();
-		for (tile, height) in modified_tiles {
+		for (tile, height) in modified_tiles
+		{
 			let chunk = tile.to_chunk_index(heightmap.width);
-			if !chunk_set.contains(&chunk) {
+			if !chunk_set.contains(&chunk)
-				chunk_modified.send(ChunkModifiedEvent { index: chunk });
+			{
+				chunk_modified.write(ChunkModifiedEvent { index: chunk });
 				chunk_set.insert(chunk);
 				commands.entity(chunks.chunks[chunk]).insert(RebuildChunk);
 			}
-			tile_modified.send(TileModifiedEvent::HeightChanged(tile, height));
+			tile_modified.write(TileModifiedEvent::HeightChanged(tile, height));
 		}
 		// commands.entity(e).insert(RebuildChunk);
 	}

game/main/src/phos.rs

@@ -2,30 +2,26 @@ use crate::camera_system::components::PhosCamera;
 use crate::map_rendering::map_init::MapInitPlugin;
 use crate::map_rendering::render_distance_system::RenderDistancePlugin;
 use crate::ui::build_ui::BuildUIPlugin;
-use crate::utlis::editor_plugin::EditorPlugin;
 use crate::utlis::tile_selection_plugin::TileSelectionPlugin;
 use crate::{camera_system::camera_plugin::PhosCameraPlugin, utlis::debug_plugin::DebugPlugin};
-use bevy::{
+use bevy::diagnostic::{EntityCountDiagnosticsPlugin, FrameTimeDiagnosticsPlugin};
-	pbr::{wireframe::WireframeConfig, CascadeShadowConfig},
+use bevy::light::CascadeShadowConfig;
-	prelude::*,
+use bevy::{pbr::wireframe::WireframeConfig, prelude::*};
-};
 use bevy_asset_loader::prelude::*;
 use bevy_rapier3d::dynamics::{Ccd, RigidBody, Velocity};
 use bevy_rapier3d::geometry::Collider;
 use bevy_rapier3d::plugin::{NoUserData, RapierPhysicsPlugin};
-use buildings::BuildingPugin;
-// use iyes_perf_ui::prelude::*;
-use shared::animation_plugin::SimpleAnimationPlugin;
 use shared::sets::GameplaySet;
 use shared::states::{GameplayState, MenuState};
 use shared::{despawn::DespawnPuglin, states::AssetLoadState};
-use units::units_plugin::UnitsPlugin;
 use world_generation::states::GeneratorState;
 
 pub struct PhosGamePlugin;
 
-impl Plugin for PhosGamePlugin {
+impl Plugin for PhosGamePlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_state(AssetLoadState::Loading);
 		app.insert_state(MenuState::Loading);
 		app.insert_state(GameplayState::Waiting);
@@ -38,14 +34,14 @@ impl Plugin for PhosGamePlugin {
 			PhosCameraPlugin,
 			MapInitPlugin,
 			RenderDistancePlugin,
-			BuildingPugin,
+			// BuildingPugin,
 			BuildUIPlugin,
-			SimpleAnimationPlugin,
+			// SimpleAnimationPlugin,
-			UnitsPlugin,
+			// UnitsPlugin,
 			DespawnPuglin,
 			TileSelectionPlugin,
-			#[cfg(debug_assertions)]
+			#[cfg(feature = "editor")]
-			EditorPlugin,
+			crate::utlis::editor_plugin::EditorPlugin,
 			#[cfg(debug_assertions)]
 			DebugPlugin,
 		));
@@ -59,8 +55,8 @@ impl Plugin for PhosGamePlugin {
 		app.add_systems(Update, spawn_sphere);
 
 		//Perf UI
-		app.add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
+		app.add_plugins(FrameTimeDiagnosticsPlugin::default())
-			.add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
+			.add_plugins(EntityCountDiagnosticsPlugin::default())
 			.add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin);
 		// .add_plugins(PerfUiPlugin);
 
@@ -75,7 +71,8 @@ impl Plugin for PhosGamePlugin {
 	}
 }
 
-fn configure_gameplay_set(app: &mut App) {
+fn configure_gameplay_set(app: &mut App)
+{
 	app.configure_sets(
 		Update,
 		GameplaySet.run_if(in_state(GeneratorState::Idle).and(in_state(MenuState::InGame))),
@@ -103,7 +100,8 @@ fn configure_gameplay_set(app: &mut App) {
 	);
 }
 
-fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>) {
+fn init_game(mut commands: Commands, mut materials: ResMut<Assets<StandardMaterial>>)
+{
 	// commands.spawn((
 	// 	PerfUiRoot::default(),
 	// 	PerfUiEntryFPS::default(),
@@ -137,21 +135,21 @@ struct SphereMat(Handle<StandardMaterial>);
 
 fn spawn_sphere(
 	mut commands: Commands,
-	cam: Query<&Transform, With<PhosCamera>>,
+	cam: Single<&Transform, With<PhosCamera>>,
 	keyboard_input: Res<ButtonInput<KeyCode>>,
 	mut meshes: ResMut<Assets<Mesh>>,
 	mat: Res<SphereMat>,
-) {
+)
+{
 	if keyboard_input.just_pressed(KeyCode::KeyF) {
-		let cam_transform = cam.single();
 		commands.spawn((
 			Mesh3d(meshes.add(Sphere::new(0.3))),
 			MeshMaterial3d(mat.0.clone()),
-			Transform::from_translation(cam_transform.translation),
+			Transform::from_translation(cam.translation),
 			Collider::ball(0.3),
 			RigidBody::Dynamic,
 			Ccd::enabled(),
-			Velocity::linear(cam_transform.forward() * 50.),
+			Velocity::linear(cam.forward() * 50.),
 		));
 	}
 }

game/main/src/prelude.rs

@@ -3,13 +3,13 @@ use bevy::pbr::ExtendedMaterial;
 use bevy::prelude::*;
 use bevy::prelude::{Component, Image, Resource};
 use bevy_asset_loader::asset_collection::AssetCollection;
-use world_generation::biome_painter::BiomePainterAsset;
 
 use crate::shader_extensions::chunk_material::ChunkMaterial;
 use crate::shader_extensions::water_material::WaterMaterial;
 
 #[derive(AssetCollection, Resource, Default)]
-pub struct PhosAssets {
+pub struct PhosAssets
+{
 	#[asset(key = "chunk_atlas")]
 	pub handle: Handle<Image>,
 	pub chunk_material_handle: Handle<ExtendedMaterial<StandardMaterial, ChunkMaterial>>,
@@ -17,24 +17,33 @@ pub struct PhosAssets {
 }
 
 #[derive(Component)]
-pub struct PhosChunk {
+pub struct PhosChunk
+{
 	pub index: usize,
 }
 
-impl PhosChunk {
+impl PhosChunk
-	pub fn new(index: usize) -> Self {
+{
+	pub fn new(index: usize) -> Self
+	{
 		return Self { index };
 	}
 }
 
+#[derive(Component)]
+pub struct WaterMesh(pub AssetId<Mesh>);
+
 #[derive(Resource, Default)]
-pub struct PhosChunkRegistry {
+pub struct PhosChunkRegistry
+{
 	pub chunks: Vec<Entity>,
 	pub waters: Vec<Entity>,
 }
 
-impl PhosChunkRegistry {
+impl PhosChunkRegistry
-	pub fn new(size: usize) -> Self {
+{
+	pub fn new(size: usize) -> Self
+	{
 		return Self {
 			chunks: Vec::with_capacity(size),
 			waters: Vec::with_capacity(size),

game/main/src/shader_extensions/chunk_material.rs

@@ -2,40 +2,49 @@ use bevy::asset::{Asset, Handle};
 use bevy::image::Image;
 use bevy::pbr::{Material, MaterialExtension};
 use bevy::reflect::TypePath;
-use bevy::render::mesh::{MeshVertexAttribute, MeshVertexBufferLayoutRef};
+use bevy::render::render_resource::AsBindGroup;
-use bevy::render::render_resource::{AsBindGroup, ShaderRef};
+use bevy::shader::ShaderRef;
 use world_generation::consts::{ATTRIBUTE_PACKED_VERTEX_DATA, ATTRIBUTE_VERTEX_HEIGHT};
 
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
-pub struct ChunkMaterial {
+pub struct ChunkMaterial
+{
 	#[texture(100, dimension = "2d_array")]
 	#[sampler(101)]
 	pub array_texture: Handle<Image>,
 }
 
-impl MaterialExtension for ChunkMaterial {
+impl MaterialExtension for ChunkMaterial
-	fn fragment_shader() -> ShaderRef {
+{
+	fn fragment_shader() -> ShaderRef
+	{
 		"shaders/world/chunk.wgsl".into()
 	}
 }
 
+#[allow(dead_code)]
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
-pub struct PackedChunkMaterial {
+pub struct PackedChunkMaterial
+{
 	#[texture(100, dimension = "2d_array")]
 	#[sampler(101)]
 	pub array_texture: Handle<Image>,
 }
 
-impl Material for PackedChunkMaterial {
+impl Material for PackedChunkMaterial
-	fn fragment_shader() -> ShaderRef {
+{
+	fn fragment_shader() -> ShaderRef
+	{
 		"shaders/world/chunk.wgsl".into()
 	}
 
-	fn vertex_shader() -> ShaderRef {
+	fn vertex_shader() -> ShaderRef
+	{
 		"shaders/world/chunk_packed.wgsl".into()
 	}
 
-	fn prepass_vertex_shader() -> ShaderRef {
+	fn prepass_vertex_shader() -> ShaderRef
+	{
 		"shaders/world/chunk_packed.wgsl".into()
 	}
 
@@ -48,11 +57,12 @@ impl Material for PackedChunkMaterial {
 	// }
 
 	fn specialize(
-		_pipeline: &bevy::pbr::MaterialPipeline<Self>,
+		_pipeline: &bevy::pbr::MaterialPipeline,
 		descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-		layout: &MeshVertexBufferLayoutRef,
+		layout: &bevy::mesh::MeshVertexBufferLayoutRef,
 		_key: bevy::pbr::MaterialPipelineKey<Self>,
-	) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
+	) -> bevy::ecs::error::Result<(), bevy::render::render_resource::SpecializedMeshPipelineError>
+	{
 		let vertex_layout = layout.0.get_layout(&[
 			// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
 			// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),

game/main/src/shader_extensions/water_material.rs

@@ -1,26 +1,30 @@
 use bevy::asset::Asset;
-use bevy::math::VectorSpace;
 use bevy::pbr::MaterialExtension;
 use bevy::prelude::*;
 use bevy::reflect::Reflect;
-use bevy::render::render_resource::{AsBindGroup, ShaderRef, ShaderType};
+use bevy::render::render_resource::{AsBindGroup, ShaderType};
+use bevy::shader::ShaderRef;
 
 #[derive(Asset, Reflect, AsBindGroup, Debug, Clone, Default)]
-pub struct WaterMaterial {
+pub struct WaterMaterial
+{
 	#[uniform(100)]
 	pub settings: WaterSettings,
 }
 
 #[derive(Debug, Clone, ShaderType, Reflect)]
-pub struct WaterSettings {
+pub struct WaterSettings
+{
 	pub offset: f32,
 	pub scale: f32,
 	pub f_power: f32,
 	pub deep_color: LinearRgba,
 }
 
-impl Default for WaterSettings {
+impl Default for WaterSettings
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self {
 			offset: 0.0,
 			scale: 1.0,
@@ -30,18 +34,21 @@ impl Default for WaterSettings {
 	}
 }
 
-impl MaterialExtension for WaterMaterial {
+impl MaterialExtension for WaterMaterial
-	fn fragment_shader() -> ShaderRef {
+{
+	fn fragment_shader() -> ShaderRef
+	{
 		"shaders/world/water.wgsl".into()
 	}
 
 	// fn specialize(
-	// 	_pipeline: &bevy::pbr::MaterialExtensionPipeline,
+	// 	pipeline: &bevy::pbr::MaterialExtensionPipeline,
 	// 	descriptor: &mut bevy::render::render_resource::RenderPipelineDescriptor,
-	// 	layout: &bevy::render::mesh::MeshVertexBufferLayout,
+	// 	layout: &bevy::mesh::MeshVertexBufferLayoutRef,
-	// 	_key: bevy::pbr::MaterialExtensionKey<Self>,
+	// 	key: bevy::pbr::MaterialExtensionKey<Self>,
-	// ) -> Result<(), bevy::render::render_resource::SpecializedMeshPipelineError> {
+	// ) -> std::result::Result<(), bevy::render::render_resource::SpecializedMeshPipelineError>
-	// 	let vertex_layout = layout.get_layout(&[
+	// {
+	// 	let vertex_layout = layout.0.get_layout(&[
 	// 		// Mesh::ATTRIBUTE_POSITION.at_shader_location(0),
 	// 		// Mesh::ATTRIBUTE_UV_0.at_shader_location(1),
 	// 		// Mesh::ATTRIBUTE_NORMAL.at_shader_location(2),

game/main/src/ui/build_ui.rs

@@ -1,38 +1,223 @@
 use bevy::{
+	camera::{visibility::RenderLayers, CameraOutputMode},
 	prelude::*,
-	render::{camera::RenderTarget, view::RenderLayers},
+	render::render_resource::BlendState,
 };
-use shared::{states::AssetLoadState, tags::MainCamera};
+use shared::states::AssetLoadState;
+
+use crate::ui::states::BuildUIState;
 pub struct BuildUIPlugin;
 
-impl Plugin for BuildUIPlugin {
+#[derive(Component, Default)]
-	fn build(&self, app: &mut App) {
+struct BuildUIItem;
+
+#[derive(Component, Default)]
+#[require(BuildUIItem)]
+struct BuildUIMenuItem;
+
+#[derive(Component, Default)]
+struct BuildMenuRoot;
+
+#[derive(Resource, Reflect, Debug, Default)]
+struct BuildUIInfo
+{
+	menu: BuildUIMenu,
+}
+
+#[derive(Default, Reflect, Debug)]
+enum BuildUIMenu
+{
+	#[default]
+	Structure,
+	Defense,
+}
+
+impl Plugin for BuildUIPlugin
+{
+	fn build(&self, app: &mut App)
+	{
 		app.add_systems(Startup, setup_cameras);
-		app.add_systems(Update, spawn_ui.run_if(in_state(AssetLoadState::LoadComplete)));
+		app.init_resource::<BuildUIInfo>();
+		app.insert_state(BuildUIState::Init);
+		app.add_systems(
+			Update,
+			(
+				spawn_ui.run_if(in_state(AssetLoadState::LoadComplete).and(in_state(BuildUIState::Init))),
+				draw_menu_ui.run_if(in_state(AssetLoadState::LoadComplete).and(in_state(BuildUIState::DrawMenu))),
+			),
+		);
+		app.add_systems(PostUpdate, cleanup_ui.run_if(in_state(BuildUIState::Cleanup)));
 	}
 }
 
-fn setup_cameras(mut commands: Commands) {
+fn setup_cameras(mut commands: Commands)
-	commands.spawn((Camera2d, IsDefaultUiCamera, UiBoxShadowSamples(6)));
+{
+	commands
+		.spawn((
+			Camera2d,
+			Camera {
+				order: 1,
+				clear_color: ClearColorConfig::None,
+				msaa_writeback: MsaaWriteback::Always,
+				output_mode: CameraOutputMode::Write {
+					blend_state: Some(BlendState::ALPHA_BLENDING),
+					clear_color: ClearColorConfig::None,
+				},
+				..default()
+			},
+			IsDefaultUiCamera,
+		))
+		.insert(RenderLayers::layer(1))
+		.insert(Msaa::Off);
 }
 
-fn spawn_ui(mut commands: Commands) {
+fn spawn_ui(mut commands: Commands, mut next_state: ResMut<NextState<BuildUIState>>)
+{
 	commands
-		.spawn((Node {
+		.spawn((
-			width: Val::Percent(100.),
+			Node {
-			height: Val::Percent(100.),
+				width: Val::Percent(100.),
-			justify_content: JustifyContent::Center,
+				height: Val::Percent(100.),
-			align_items: AlignItems::End,
+				justify_content: JustifyContent::Center,
-			..default()
+				align_items: AlignItems::End,
-		},))
+				..default()
-		.insert(PickingBehavior::IGNORE)
+			},
-		.with_children(|parent| {
+			RenderLayers::layer(1),
-			parent.spawn((
+			Name::new("Build UI Root"),
-				Node {
+			BuildUIItem,
-					width: Val::Px(500.),
+		))
-					..Default::default()
+		// .insert(PickingBehavior::IGNORE)
-				},
+		.with_children(|build_root| {
-				BackgroundColor(LinearRgba::GREEN.into()),
+			build_root
-			));
+				.spawn((
+					Name::new("Build UI"),
+					Node {
+						width: Val::Px(500.),
+						height: Val::Px(100.),
+						justify_content: JustifyContent::Stretch,
+						flex_direction: FlexDirection::Column,
+						..default()
+					},
+					BackgroundColor(LinearRgba::GREEN.into()),
+				))
+				.with_children(|build_ui| {
+					build_ui.spawn((
+						Name::new("Menu Root"),
+						BuildMenuRoot,
+						Node {
+							width: Val::Percent(100.),
+							height: Val::Px(70.),
+							column_gap: Val::Px(5.),
+							padding: UiRect::all(Val::Px(2.)),
+							flex_direction: FlexDirection::Row,
+							overflow: Overflow::scroll_x(),
+							..default()
+						},
+					));
+					build_ui
+						.spawn((
+							Name::new("Toolbar"),
+							Node {
+								width: Val::Percent(100.),
+								height: Val::Px(30.),
+								column_gap: Val::Px(5.),
+								padding: UiRect::horizontal(Val::Px(10.)),
+								justify_content: JustifyContent::Stretch,
+								align_self: AlignSelf::End,
+								..default()
+							},
+							BackgroundColor(LinearRgba::BLUE.into()),
+						))
+						.with_children(|toolbar| {
+							for i in 0..6
+							{
+								toolbar.spawn((
+									Name::new(format!("Button {}", i)),
+									Button,
+									Node {
+										height: Val::Percent(100.),
+										width: Val::Percent(100.),
+										align_items: AlignItems::Center,
+										justify_content: JustifyContent::Center,
+										..default()
+									},
+									BackgroundColor(LinearRgba::WHITE.into()),
+									children![(
+										Text::new(format!("Button {}", i)),
+										TextFont {
+											font_size: 15.,
+											..default()
+										},
+										TextColor(LinearRgba::BLACK.into()),
+										TextShadow {
+											offset: Vec2::splat(2.),
+											..default()
+										}
+									)],
+								));
+							}
+						});
+				});
 		});
+
+	next_state.set(BuildUIState::DrawMenu);
+}
+
+fn draw_menu_ui(
+	mut commands: Commands,
+	menu_root: Single<Entity, With<BuildMenuRoot>>,
+	menu_items: Query<Entity, With<BuildUIMenuItem>>,
+	menu_info: Res<BuildUIInfo>,
+	mut next: ResMut<NextState<BuildUIState>>,
+)
+{
+	for entity in menu_items.iter()
+	{
+		commands.entity(entity).despawn();
+	}
+	info!("Draw Menu");
+	match menu_info.menu
+	{
+		BuildUIMenu::Structure => draw_structure_ui(commands, menu_root.into_inner()),
+		BuildUIMenu::Defense => (),
+	}
+	next.set(BuildUIState::Update);
+}
+
+fn draw_structure_ui(mut commands: Commands, root: Entity)
+{
+	commands.entity(root).with_children(|root| {
+		for i in 0..10
+		{
+			root.spawn((
+				BuildUIMenuItem,
+				Node {
+					height: Val::Percent(100.),
+					width: Val::Px(100.),
+					display: Display::Grid,
+					grid_template_rows: vec![RepeatedGridTrack::px(1, 100.), RepeatedGridTrack::fr(1, 1.)],
+					..default()
+				},
+				children![
+					(
+						Node {
+							height: Val::Px(100.),
+							width: Val::Px(100.),
+							..default()
+						},
+						BackgroundColor(LinearRgba::RED.into())
+					),
+					(Text::new(format!("Icon {}", i))),
+				],
+			));
+		}
+	});
+}
+
+fn cleanup_ui(mut commands: Commands, ui_items: Query<Entity, With<BuildUIItem>>)
+{
+	for entity in ui_items.iter()
+	{
+		commands.entity(entity).despawn();
+	}
 }

game/main/src/ui/mod.rs

@@ -1 +1,2 @@
 pub mod build_ui;
+pub mod states;

game/main/src/ui/states.rs

@@ -0,0 +1,10 @@
+use bevy::prelude::*;
+
+#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
+pub enum BuildUIState
+{
+	Init,
+	DrawMenu,
+	Update,
+	Cleanup,
+}

game/main/src/utlis/chunk_utils.rs

@@ -4,19 +4,18 @@ use bevy::{
 	asset::Assets,
 	ecs::system::Res,
 	math::{IVec2, UVec2, Vec3},
-	render::mesh::Mesh,
+	mesh::Mesh,
 };
 use bevy_rapier3d::geometry::{Collider, TriMeshFlags};
+use hex::prelude::*;
 use rayon::iter::{IntoParallelRefMutIterator, ParallelIterator};
 use world_generation::{
 	biome_painter::BiomePainter,
 	generators::{
 		chunk_colliders::generate_chunk_collider,
 		mesh_generator::{generate_chunk_mesh, generate_chunk_water_mesh},
-		packed_mesh_generator::generate_packed_chunk_mesh,
 	},
-	hex_utils::offset_to_world,
+	prelude::{Map, MeshChunkData},
-	prelude::{Chunk, Map, MeshChunkData},
 	tile_manager::TileAsset,
 	tile_mapper::TileMapperAsset,
 };
@@ -26,7 +25,8 @@ pub fn paint_map(
 	painter: &BiomePainter,
 	tiles: &Res<Assets<TileAsset>>,
 	mappers: &Res<Assets<TileMapperAsset>>,
-) {
+)
+{
 	map.chunks.par_iter_mut().for_each(|chunk: &mut Chunk| {
 		paint_chunk(chunk, painter, tiles, mappers);
 	});
@@ -37,9 +37,12 @@ pub fn paint_chunk(
 	painter: &BiomePainter,
 	tiles: &Res<Assets<TileAsset>>,
 	mappers: &Res<Assets<TileMapperAsset>>,
-) {
+)
-	for z in 0..Chunk::SIZE {
+{
-		for x in 0..Chunk::SIZE {
+	for z in 0..Chunk::SIZE
+	{
+		for x in 0..Chunk::SIZE
+		{
 			let idx = x + z * Chunk::SIZE;
 			let height = chunk.heights[idx];
 			let biome_id = chunk.biome_id[idx];
@@ -58,7 +61,8 @@ pub fn prepare_chunk_mesh(
 	chunk_offset: IVec2,
 	chunk_index: usize,
 	map_size: UVec2,
-) -> (Mesh, Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize) {
+) -> (Mesh, Mesh, (Vec<Vec3>, Vec<[u32; 3]>), Vec3, usize)
+{
 	#[cfg(feature = "tracing")]
 	let _gen_mesh = info_span!("Generate Chunk").entered();
 	let chunk_mesh = generate_chunk_mesh(chunk);
@@ -80,14 +84,16 @@ pub fn prepare_chunk_mesh_with_collider(
 	chunk_offset: IVec2,
 	chunk_index: usize,
 	map_size: UVec2,
-) -> (Mesh, Mesh, Collider, Vec3, usize) {
+) -> (Mesh, Mesh, Collider, Vec3, usize)
+{
 	let (chunk_mesh, water_mesh, (col_verts, col_indicies), pos, index) =
 		prepare_chunk_mesh(chunk, sealevel, chunk_offset, chunk_index, map_size);
 	let collider: Collider;
 	{
 		#[cfg(feature = "tracing")]
 		let _collider_span = info_span!("Create Collider Trimesh").entered();
-		collider = Collider::trimesh_with_flags(col_verts, col_indicies, TriMeshFlags::DELETE_DUPLICATE_TRIANGLES);
+		collider = Collider::trimesh_with_flags(col_verts, col_indicies, TriMeshFlags::DELETE_DUPLICATE_TRIANGLES)
+			.expect("Failed to generate chunk collision mesh");
 	}
 	return (chunk_mesh, water_mesh, collider, pos, index);
 }

game/main/src/utlis/debug_plugin.rs

@@ -1,4 +1,4 @@
-use bevy::{gizmos::gizmos, prelude::*};
+use bevy::prelude::*;
 use shared::states::GameplayState;
 use shared::{resources::TileUnderCursor, sets::GameplaySet};
 use world_generation::{
@@ -11,8 +11,10 @@ use crate::camera_system::components::{PhosCamera, PhosOrbitCamera};
 
 pub struct DebugPlugin;
 
-impl Plugin for DebugPlugin {
+impl Plugin for DebugPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.insert_state(DebugState::Base);
 
 		app.add_systems(
@@ -29,7 +31,7 @@ impl Plugin for DebugPlugin {
 				.run_if(in_state(DebugState::Verbose)),
 		);
 
-		// app.add_systems(Update, camera_debug.in_set(GameplaySet));
+		app.add_systems(Update, camera_debug.in_set(GameplaySet));
 		app.add_systems(Update, regenerate_map.run_if(in_state(GeneratorState::Idle)));
 
 		app.insert_resource(Shape(Polyline3d::new([
@@ -45,10 +47,11 @@ impl Plugin for DebugPlugin {
 }
 
 #[derive(Resource)]
-struct Shape(pub Polyline3d<7>);
+struct Shape(pub Polyline3d);
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum DebugState {
+pub enum DebugState
+{
 	Base,
 	None,
 	Verbose,
@@ -58,15 +61,19 @@ fn regenerate_map(
 	mut generator_state: ResMut<NextState<GeneratorState>>,
 	mut gameplay_state: ResMut<NextState<GameplayState>>,
 	input: Res<ButtonInput<KeyCode>>,
-) {
+)
-	if input.just_pressed(KeyCode::KeyR) {
+{
+	if input.just_pressed(KeyCode::KeyR)
+	{
 		generator_state.set(GeneratorState::Regenerate);
 		gameplay_state.set(GameplayState::PlaceHQ);
 	}
 }
 
-fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_under_cursor: Res<TileUnderCursor>) {
+fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_under_cursor: Res<TileUnderCursor>)
-	if let Some(contact) = tile_under_cursor.0 {
+{
+	if let Some(contact) = tile_under_cursor.0
+	{
 		let height = map.sample_height(&contact.tile);
 		gizmos.primitive_3d(&shape.0, contact.tile.to_world(height + 0.01), Color::WHITE);
 
@@ -78,8 +85,11 @@ fn show_tile_heights(map: Res<Map>, mut gizmos: Gizmos, shape: Res<Shape>, tile_
 	}
 }
 
-fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos) {
+#[allow(dead_code)]
-	for i in 0..WATER_HEX_CORNERS.len() {
+fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos)
+{
+	for i in 0..WATER_HEX_CORNERS.len()
+	{
 		let p = pos + WATER_HEX_CORNERS[i];
 		let p2 = pos + WATER_HEX_CORNERS[(i + 1) % WATER_HEX_CORNERS.len()];
 
@@ -87,8 +97,9 @@ fn show_water_corners(pos: Vec3, gizmos: &mut Gizmos) {
 	}
 }
 
-fn camera_debug(mut cam_query: Query<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos) {
+fn camera_debug(cam_query: Single<(&PhosCamera, &PhosOrbitCamera)>, mut gizmos: Gizmos)
-	let (config, orbit) = cam_query.single();
+{
+	let (_config, orbit) = cam_query.into_inner();
 
 	gizmos.sphere(orbit.target, 0.3, LinearRgba::RED);
 	let cam_proxy = orbit.target - (orbit.forward * 10.0);

game/main/src/utlis/editor_plugin.rs

@@ -1,5 +1,6 @@
-use bevy::{prelude::*, render::render_asset::RenderAssetUsages};
+use bevy::asset::RenderAssetUsages;
-use bevy_inspector_egui::bevy_egui::EguiContexts;
+use bevy::prelude::*;
+use bevy_inspector_egui::bevy_egui::{EguiContexts, EguiTextureHandle};
 use bevy_inspector_egui::egui::{self};
 use image::{ImageBuffer, Rgba};
 use world_generation::biome_asset::BiomeAsset;
@@ -10,22 +11,25 @@ use world_generation::{map::map_utils::render_map, prelude::Map, states::Generat
 
 pub struct EditorPlugin;
 
-impl Plugin for EditorPlugin {
+impl Plugin for EditorPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<UIState>();
 
-		// app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
+		app.add_systems(PostUpdate, prepare_image.run_if(in_state(GeneratorState::SpawnMap)));
-		// app.add_systems(
+		app.add_systems(
-		// 	Update,
+			Update,
-		// 	(render_map_ui, update_map_render, asset_reloaded).run_if(in_state(GeneratorState::Idle)),
+			(render_map_ui, update_map_render, asset_reloaded).run_if(in_state(GeneratorState::Idle)),
-		// );
+		);
 	}
 }
 
 #[derive(Resource)]
 struct MapImage(pub Handle<Image>);
 
-pub fn prepare_image(mut images: ResMut<Assets<Image>>, heightmap: Res<Map>, mut commands: Commands) {
+pub fn prepare_image(mut images: ResMut<Assets<Image>>, heightmap: Res<Map>, mut commands: Commands)
+{
 	let image = render_map(&heightmap, 0.1);
 	let handle = images.add(Image::from_dynamic(image.into(), true, RenderAssetUsages::RENDER_WORLD));
 
@@ -33,14 +37,17 @@ pub fn prepare_image(mut images: ResMut<Assets<Image>>, heightmap: Res<Map>, mut
 }
 
 #[derive(Resource)]
-struct UIState {
+struct UIState
+{
 	pub is_open: bool,
 	pub target_map_type: MapDisplayType,
 	pub cur_map_type: MapDisplayType,
 }
 
-impl Default for UIState {
+impl Default for UIState
-	fn default() -> Self {
+{
+	fn default() -> Self
+	{
 		Self {
 			is_open: true,
 			target_map_type: default(),
@@ -50,7 +57,8 @@ impl Default for UIState {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Default)]
-enum MapDisplayType {
+enum MapDisplayType
+{
 	#[default]
 	HeightMap,
 	Biomes,
@@ -61,19 +69,23 @@ enum MapDisplayType {
 }
 
 fn asset_reloaded(
-	mut asset_events: EventReader<AssetEvent<BiomeAsset>>,
+	mut asset_events: MessageReader<AssetEvent<BiomeAsset>>,
-	mut biomes: ResMut<Assets<BiomeAsset>>,
+	biomes: Res<Assets<BiomeAsset>>,
 	biome_painter: Res<BiomePainterAsset>,
 	mut commands: Commands,
-) {
+)
+{
 	let mut rebuild = false;
-	for event in asset_events.read() {
+	for event in asset_events.read()
-		match event {
+	{
+		match event
+		{
 			AssetEvent::Modified { .. } => rebuild = true,
 			_ => (),
 		}
 	}
-	if rebuild {
+	if rebuild
+	{
 		let painter = biome_painter.build(&biomes);
 		commands.insert_resource(painter);
 	}
@@ -85,11 +97,11 @@ fn render_map_ui(
 	biome_map: Res<BiomeMap>,
 	mut contexts: EguiContexts,
 	mut state: ResMut<UIState>,
-) {
+)
-	let id = contexts.add_image(image.0.clone_weak());
+{
-
+	let id = contexts.add_image(EguiTextureHandle::Weak(image.0.id()));
 	let mut map_type = state.target_map_type;
-	let ctx = contexts.ctx_mut();
+	let ctx = contexts.ctx_mut().expect("Failed to get egui context");
 	egui::Window::new("Map").open(&mut state.is_open).show(ctx, |ui| {
 		ui.label("Map Test");
 		egui::ComboBox::from_label("Display Type")
@@ -120,7 +132,8 @@ fn render_map_ui(
 			[512.0, 512.0],
 		)));
 
-		if ui.button("Save Image").clicked() {
+		if ui.button("Save Image").clicked()
+		{
 			let img = get_map_image(&heightmap, &biome_map, map_type);
 			_ = img.save(format!("{:?}.png", map_type));
 		}
@@ -135,22 +148,28 @@ fn update_map_render(
 	heightmap: Res<Map>,
 	biome_map: Res<BiomeMap>,
 	image: Res<MapImage>,
-) {
+)
-	if state.cur_map_type == state.target_map_type {
+{
+	if state.cur_map_type == state.target_map_type
+	{
 		return;
 	}
 
 	let result = get_map_image(&heightmap, &biome_map, state.target_map_type);
-	images.insert(
+	images
-		image.0.id(),
+		.insert(
-		Image::from_dynamic(result.into(), true, RenderAssetUsages::RENDER_WORLD),
+			image.0.id(),
-	);
+			Image::from_dynamic(result.into(), true, RenderAssetUsages::RENDER_WORLD),
+		)
+		.expect("Failed to update map image");
 
 	state.cur_map_type = state.target_map_type;
 }
 
-fn get_map_image(heightmap: &Map, biome_map: &BiomeMap, map_type: MapDisplayType) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
+fn get_map_image(heightmap: &Map, biome_map: &BiomeMap, map_type: MapDisplayType) -> ImageBuffer<Rgba<u8>, Vec<u8>>
-	return match map_type {
+{
+	return match map_type
+	{
 		MapDisplayType::HeightMap => render_map(&heightmap, 0.1),
 		MapDisplayType::Biomes => render_biome_map(&heightmap, &biome_map),
 		MapDisplayType::BiomeNoise => render_biome_noise_map(&biome_map, Vec3::ONE),

game/main/src/utlis/mod.rs

@@ -1,4 +1,5 @@
 pub mod chunk_utils;
 pub mod debug_plugin;
+#[cfg(feature = "editor")]
 pub mod editor_plugin;
 pub mod tile_selection_plugin;

game/main/src/utlis/tile_selection_plugin.rs

@@ -1,17 +1,18 @@
 use bevy::{prelude::*, window::PrimaryWindow};
-use bevy_rapier3d::{
+use bevy_rapier3d::{plugin::ReadRapierContext, prelude::QueryFilter};
-	plugin::{RapierContext, ReadDefaultRapierContext},
+use hex::prelude::*;
-	prelude::QueryFilter,
-};
 use shared::{
 	resources::{TileContact, TileUnderCursor},
 	tags::MainCamera,
 };
-use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
+use world_generation::{prelude::Map, states::GeneratorState};
+
 pub struct TileSelectionPlugin;
 
-impl Plugin for TileSelectionPlugin {
+impl Plugin for TileSelectionPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<TileUnderCursor>();
 		app.add_systems(
 			PreUpdate,
@@ -21,28 +22,29 @@ impl Plugin for TileSelectionPlugin {
 }
 
 fn update_tile_under_cursor(
-	cam_query: Query<(&GlobalTransform, &Camera), With<MainCamera>>,
+	cam_query: Single<(&GlobalTransform, &Camera), With<MainCamera>>,
-	window: Query<&Window, With<PrimaryWindow>>,
+	window: Single<&Window, With<PrimaryWindow>>,
-	rapier_context: ReadDefaultRapierContext,
+	rapier: ReadRapierContext,
 	map: Res<Map>,
 	mut tile_under_cursor: ResMut<TileUnderCursor>,
-) {
+)
-	let win_r = window.get_single();
+{
-	if win_r.is_err() {
+	let (cam_transform, camera) = cam_query.into_inner();
-		return;
+	let Some(cursor_pos) = window.cursor_position()
-	}
+	else
-	let win = win_r.unwrap();
+	{
-
-	let (cam_transform, camera) = cam_query.single();
-	let Some(cursor_pos) = win.cursor_position() else {
 		return;
 	};
 
-	let Ok(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
+	let Ok(cam_ray) = camera.viewport_to_world(cam_transform, cursor_pos)
+	else
+	{
 		return;
 	};
 
-	let collision = rapier_context.cast_ray(
+	let ctx = rapier.single().expect("Failed to get rapier read context");
+
+	let collision = ctx.cast_ray(
 		cam_ray.origin,
 		cam_ray.direction.into(),
 		500.,
@@ -50,11 +52,13 @@ fn update_tile_under_cursor(
 		QueryFilter::only_fixed(),
 	);
 
-	if let Some((_e, dist)) = collision {
+	if let Some((_e, dist)) = collision
+	{
 		let contact_point = cam_ray.get_point(dist);
 		let contact_coord = HexCoord::from_world_pos(contact_point);
 		//todo: handle correct tile detection when contacting a tile from the side
-		if !map.is_in_bounds(&contact_coord) {
+		if !map.is_in_bounds(&contact_coord)
+		{
 			tile_under_cursor.0 = None;
 			return;
 		}
@@ -64,7 +68,9 @@ fn update_tile_under_cursor(
 			contact_point,
 			contact_coord.to_world(surface),
 		));
-	} else {
+	}
+	else
+	{
 		tile_under_cursor.0 = None;
 	}
 }

game/resources/Cargo.toml

@@ -4,14 +4,14 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.15.1"
+bevy = "0.18.0"
 world_generation = { path = "../../engine/world_generation" }
 shared = { path = "../shared" }
-serde = { version = "1.0.204", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.120"
+serde_json = "1.0.149"
-ron = "0.8.1"
+ron = "0.12.0"
-bevy_asset_loader = { version = "0.22.0", features = [
+bevy_asset_loader = { version = "0.25.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }

game/shared/Cargo.toml

@@ -6,9 +6,10 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.15.1"
+bevy = "0.18.0"
-serde = { version = "1.0.204", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 world_generation = { path = "../../engine/world_generation" }
+hex = { path = "../../engine/hex" }
 
 
 [features]

game/shared/src/component_defination.rs

@@ -1,20 +1,20 @@
-use bevy::{
+use bevy::{ecs::system::EntityCommands, prelude::*};
-	ecs::system::EntityCommands, math::{Quat, Vec3}, prelude::*
-};
 use serde::{Deserialize, Serialize};
 
 use crate::prefab_defination::AnimationComponent;
 #[derive(Serialize, Deserialize, Debug)]
-pub struct ComponentDefination {
+pub struct ComponentDefination
+{
 	pub path: String,
 	pub animations: Vec<AnimationComponent>,
 }
 
-
+impl ComponentDefination
-impl ComponentDefination {
+{
-	pub fn apply(&self, commands: &mut EntityCommands){
+	pub fn apply(&self, commands: &mut EntityCommands)
+	{
 		for c in &self.animations {
 			c.apply(commands);
 		}
 	}
-}
+}

game/shared/src/coords.rs

@@ -0,0 +1,69 @@
+use bevy::prelude::*;
+use hex::prelude::*;
+
+#[derive(Default, Debug, Reflect)]
+pub struct CoordsCollection
+{
+	points: Vec<IVec2>,
+	origin: IVec2,
+	translation: IVec2,
+	rotation: i32,
+}
+
+impl CoordsCollection
+{
+	pub fn from_hex(coords: Vec<HexCoord>) -> Self
+	{
+		CoordsCollection {
+			points: coords.iter().map(|c| c.hex.xy()).collect(),
+			..default()
+		}
+	}
+
+	pub fn from_points(points: Vec<IVec2>) -> Self
+	{
+		CoordsCollection { points, ..default() }
+	}
+
+	pub fn with_translation(mut self, translation: &HexCoord) -> Self
+	{
+		self.translation = translation.hex.xy();
+		return self;
+	}
+
+	pub fn with_translation_vec(mut self, translation: IVec2) -> Self
+	{
+		self.translation = translation;
+		return self;
+	}
+
+	pub fn with_origin(mut self, orign: &HexCoord) -> Self
+	{
+		self.origin = orign.hex.xy();
+		return self;
+	}
+
+	pub fn with_rotation(mut self, rotation: i32) -> Self
+	{
+		self.rotation = rotation;
+		return self;
+	}
+
+	pub fn get_coords(&self) -> Vec<HexCoord>
+	{
+		let center = HexCoord::from_axial(self.origin);
+		return self
+			.points
+			.iter()
+			.map(|p| HexCoord::from_axial(p + self.origin).rotate_around(&center, self.rotation))
+			.collect();
+	}
+}
+
+impl Into<Vec<HexCoord>> for CoordsCollection
+{
+	fn into(self) -> Vec<HexCoord>
+	{
+		self.get_coords()
+	}
+}

game/shared/src/despawn.rs

@@ -34,7 +34,7 @@ fn despawn_at(mut commands: Commands, time: Res<Time>, entities: Query<(Entity,
 fn despawn_after(mut commands: Commands, mut entities: Query<(&mut DespawnAfter, Entity)>, time: Res<Time>) {
 	for (mut after, entity) in &mut entities.iter_mut() {
 		after.0.tick(time.delta());
-		if after.0.finished() {
+		if after.0.is_finished() {
 			commands.entity(entity).despawn();
 		}
 	}

game/shared/src/events.rs

@@ -1,13 +1,15 @@
 use bevy::prelude::*;
-use world_generation::hex_utils::*;
+use hex::prelude::*;
 
-#[derive(Event)]
+#[derive(Message)]
-pub enum TileModifiedEvent {
+pub enum TileModifiedEvent
+{
 	HeightChanged(HexCoord, f32),
 	TypeChanged(HexCoord, usize),
 }
 
-#[derive(Event)]
+#[derive(Message)]
-pub struct ChunkModifiedEvent {
+pub struct ChunkModifiedEvent
+{
 	pub index: usize,
 }

game/shared/src/identifiers.rs

@@ -1,9 +1,9 @@
 use bevy::reflect::Reflect;
 use serde::{Deserialize, Serialize};
-use world_generation::hex_utils::HexCoord;
 
 #[derive(Serialize, Deserialize, Debug, Reflect)]
-pub struct ResourceIdentifier {
+pub struct ResourceIdentifier
+{
 	pub id: u32,
 	pub qty: u32,
 }

game/shared/src/lib.rs

@@ -1,20 +1,22 @@
 use bevy::reflect::Reflect;
 use serde::{Deserialize, Serialize};
 
+pub mod animation_plugin;
 pub mod building;
+pub mod component_defination;
+pub mod coords;
 pub mod despawn;
 pub mod events;
 pub mod identifiers;
+pub mod prefab_defination;
 pub mod resources;
 pub mod sets;
 pub mod states;
 pub mod tags;
-pub mod prefab_defination;
-pub mod component_defination;
-pub mod animation_plugin;
 
 #[derive(Debug, Serialize, Deserialize)]
-pub enum Tier {
+pub enum Tier
+{
 	Zero,
 	One,
 	Two,
@@ -23,7 +25,8 @@ pub enum Tier {
 }
 
 #[derive(Serialize, Deserialize, Debug, Reflect)]
-pub enum StatusEffect {
+pub enum StatusEffect
+{
 	UnitRange(f32),
 	UnitAttack(f32),
 	UnitHealth(f32),

game/shared/src/prefab_defination.rs

@@ -1,12 +1,13 @@
 use bevy::{
-	ecs::system::{EntityCommand, EntityCommands},
+	ecs::{relationship::RelatedSpawnerCommands, system::EntityCommands},
 	gltf::{Gltf, GltfMesh},
 	math::{Quat, Vec3},
 	prelude::*,
 };
 use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize, Debug)]
-pub struct PrefabDefination {
+pub struct PrefabDefination
+{
 	pub path: String,
 	pub pos: Vec3,
 	pub rot: Vec3,
@@ -14,38 +15,54 @@ pub struct PrefabDefination {
 	pub animations: Option<Vec<AnimationComponent>>,
 }
 
-impl PrefabDefination {
+impl PrefabDefination
-	pub fn spawn_recursive(&self, gltf: &Gltf, commands: &mut ChildBuilder, meshes: &Assets<GltfMesh>) {
+{
+	pub fn spawn_recursive(
+		&self,
+		gltf: &Gltf,
+		commands: &mut RelatedSpawnerCommands<ChildOf>,
+		meshes: &Assets<GltfMesh>,
+	)
+	{
 		let mesh_handle = &gltf.named_meshes[&self.path.clone().into_boxed_str()];
 		if let Some(gltf_mesh) = meshes.get(mesh_handle.id()) {
-			let (m, mat) = gltf_mesh.unpack();
+			if let Some(primitive) = gltf_mesh.primitives.first() {
-			let mut entity = commands.spawn((
+				let mesh = primitive.mesh.clone();
-				Mesh3d(m),
+				let mat = primitive
-				MeshMaterial3d(mat),
+					.material
-				Transform::from_translation(self.pos).with_rotation(Quat::from_euler(
+					.clone()
-					bevy::math::EulerRot::XYZ,
+					.expect(format!("Mesh '{}' does not have a meterial", primitive.name.as_str()).as_str());
-					self.rot.x,
+				let mut entity = commands.spawn((
-					self.rot.y,
+					Mesh3d(mesh),
-					self.rot.z,
+					MeshMaterial3d(mat),
-				)),
+					Transform::from_translation(self.pos).with_rotation(Quat::from_euler(
-			));
+						bevy::math::EulerRot::XYZ,
-			if let Some(children) = &self.children {
+						self.rot.x,
-				entity.with_children(|b| {
+						self.rot.y,
-					for child in children {
+						self.rot.z,
-						child.spawn_recursive(gltf, b, meshes);
+					)),
-					}
+				));
-				});
+				if let Some(children) = &self.children {
+					entity.with_children(|b| {
+						for child in children {
+							child.spawn_recursive(gltf, b, meshes);
+						}
+					});
+				}
 			}
 		}
 	}
 }
 
-pub trait UnpackGltfMesh {
+pub trait UnpackGltfMesh
+{
 	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>);
 }
 
-impl UnpackGltfMesh for GltfMesh {
+impl UnpackGltfMesh for GltfMesh
-	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>) {
+{
+	fn unpack(&self) -> (Handle<Mesh>, Handle<StandardMaterial>)
+	{
 		let p = &self.primitives[0];
 		let mut mat: Handle<StandardMaterial> = default();
 		if let Some(mesh_material) = &p.material {
@@ -56,19 +73,23 @@ impl UnpackGltfMesh for GltfMesh {
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub enum AnimationComponent {
+pub enum AnimationComponent
+{
 	Rotation(RotationAnimation),
 	Slider,
 }
 
 #[derive(Serialize, Deserialize, Debug, Component, Clone, Copy)]
-pub struct RotationAnimation {
+pub struct RotationAnimation
+{
 	pub axis: Vec3,
 	pub speed: f32,
 }
 
-impl AnimationComponent {
+impl AnimationComponent
-	pub fn apply(&self, commands: &mut EntityCommands) {
+{
+	pub fn apply(&self, commands: &mut EntityCommands)
+	{
 		match self {
 			AnimationComponent::Rotation(comp) => {
 				commands.insert(comp.clone());

game/shared/src/resources.rs

@@ -1,18 +1,21 @@
 use bevy::prelude::*;
-use world_generation::hex_utils::HexCoord;
+use hex::prelude::*;
 
 #[derive(Resource, Default)]
 pub struct TileUnderCursor(pub Option<TileContact>);
 
 #[derive(Clone, Copy)]
-pub struct TileContact {
+pub struct TileContact
+{
 	pub tile: HexCoord,
 	pub point: Vec3,
 	pub surface: Vec3,
 }
 
-impl TileContact {
+impl TileContact
-	pub fn new(tile: HexCoord, contact: Vec3, surface: Vec3) -> Self {
+{
+	pub fn new(tile: HexCoord, contact: Vec3, surface: Vec3) -> Self
+	{
 		return Self {
 			tile,
 			point: contact,

game/shared/src/states.rs

@@ -1,7 +1,8 @@
 use bevy::prelude::*;
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum MenuState {
+pub enum MenuState
+{
 	Loading,
 	Startup,
 	MainMenu,
@@ -10,14 +11,16 @@ pub enum MenuState {
 }
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum GameplayState {
+pub enum GameplayState
+{
 	Waiting,
 	PlaceHQ,
 	Playing,
 }
 
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum AssetLoadState {
+pub enum AssetLoadState
+{
 	Loading,
 	FinalizeAssets,
 	LoadComplete,

game/units/Cargo.toml

@@ -4,21 +4,22 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = "0.15.1"
+bevy = "0.18.0"
 world_generation = { path = "../../engine/world_generation" }
+hex = { path = "../../engine/hex" }
 shared = { path = "../shared" }
-bevy_rapier3d = "0.28.0"
+bevy_rapier3d = "0.33.0"
-serde = { version = "1.0.204", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 asset_loader = { path = "../../engine/asset_loader" }
-serde_json = "1.0.120"
+serde_json = "1.0.149"
-ron = "0.8.1"
+ron = "0.12.0"
-bevy_asset_loader = { version = "0.22.0", features = [
+bevy_asset_loader = { version = "0.25.0", features = [
 	"standard_dynamic_assets",
 	"3d",
 ] }
 quadtree_rs = "0.1.3"
-pathfinding = "4.11.0"
+pathfinding = "4.14.0"
-ordered-float = "4.3.0"
+ordered-float = "5.1.0"
 
 [features]
 tracing = ["bevy/trace_tracy"]

game/units/src/assets/unit_asset.rs

@@ -20,13 +20,7 @@ impl UnitAsset {
 	pub fn spawn(&self, transform: Transform) -> CommandQueue {
 		let mut commands = CommandQueue::default();
 
-		let bundle = (
+		let bundle = (transform, Unit);
-			PbrBundle {
-				transform: transform,
-				..default()
-			},
-			Unit,
-		);
 		let domain = self.domain.clone();
 		commands.push(move |world: &mut World| {
 			let mut e = world.spawn(bundle);

game/units/src/components.rs

@@ -1,6 +1,6 @@
 use bevy::{ecs::world::CommandQueue, prelude::*, tasks::Task};
+use hex::prelude::*;
 use serde::{Deserialize, Serialize};
-use world_generation::hex_utils::HexCoord;
 
 #[derive(Component, Debug)]
 pub struct Unit;
@@ -13,7 +13,8 @@ pub struct LandUnit;
 pub struct NavalUnit;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy)]
-pub enum UnitDomain {
+pub enum UnitDomain
+{
 	Land,
 	Air,
 	Naval,

game/units/src/lib.rs

@@ -1,6 +1,3 @@
-use bevy::reflect::Reflect;
-use serde::{Deserialize, Serialize};
-
 pub mod assets;
 pub mod components;
 pub mod nav_data;
@@ -11,6 +8,7 @@ pub mod units_plugin;
 pub mod units_spacial_set;
 
 #[derive(Clone, Copy)]
-pub enum UnitType {
+pub enum UnitType
+{
 	Basic,
 }

game/units/src/nav_data.rs

@@ -1,21 +1,27 @@
 use bevy::prelude::*;
+use hex::prelude::*;
 use ordered_float::OrderedFloat;
-use world_generation::{hex_utils::HexCoord, prelude::Map};
+use world_generation::prelude::Map;
 
 #[derive(Clone, Resource)]
-pub struct NavData {
+pub struct NavData
+{
 	pub tiles: Vec<NavTile>,
 	pub map_height: usize,
 	pub map_width: usize,
 }
 
-impl NavData {
+impl NavData
-	pub fn get_neighbors(&self, coord: &HexCoord) -> Vec<(HexCoord, OrderedFloat<f32>)> {
+{
+	pub fn get_neighbors(&self, coord: &HexCoord) -> Vec<(HexCoord, OrderedFloat<f32>)>
+	{
 		let mut neighbors = Vec::with_capacity(6);
 		let cur_height = self.get_height(coord);
-		for i in 0..6 {
+		for i in 0..6
+		{
 			let n = coord.get_neighbor(i);
-			if !self.is_in_bounds(&n) {
+			if !self.is_in_bounds(&n)
+			{
 				continue;
 			}
 			let n_height = self.get_height(&n);
@@ -23,27 +29,33 @@ impl NavData {
 		}
 		return neighbors;
 	}
-	pub fn get(&self, coord: &HexCoord) -> &NavTile {
+	pub fn get(&self, coord: &HexCoord) -> &NavTile
+	{
 		return &self.tiles[coord.to_index(self.map_width)];
 	}
 
-	pub fn get_height(&self, coord: &HexCoord) -> f32 {
+	pub fn get_height(&self, coord: &HexCoord) -> f32
+	{
 		return self.tiles[coord.to_index(self.map_width)].height;
 	}
 
-	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool {
+	pub fn is_in_bounds(&self, pos: &HexCoord) -> bool
+	{
 		return pos.is_in_bounds(self.map_height, self.map_width);
 	}
 
-	pub fn build(map: &Map) -> NavData {
+	pub fn build(map: &Map) -> NavData
+	{
 		#[cfg(feature = "tracing")]
 		let _path_span = info_span!("Build Nav Data").entered();
 		let mut tiles = Vec::with_capacity(map.get_tile_count());
 		let h = map.get_tile_height();
 		let w = map.get_tile_width();
-		for y in 0..h {
+		for y in 0..h
-			for x in 0..w {
+		{
-				let coord = HexCoord::from_grid_pos(x, y);
+			for x in 0..w
+			{
+				let coord = HexCoord::from_offset_pos(x, y);
 				let height = map.sample_height(&coord);
 				let tile = NavTile {
 					coord,
@@ -61,14 +73,17 @@ impl NavData {
 		};
 	}
 
-	pub fn update(&mut self, map: &Map) {
+	pub fn update(&mut self, map: &Map)
+	{
 		#[cfg(feature = "tracing")]
 		let _path_span = info_span!("Update Nav Data").entered();
 		let h = map.get_tile_height();
 		let w = map.get_tile_width();
-		for y in 0..h {
+		for y in 0..h
-			for x in 0..w {
+		{
-				let coord = HexCoord::from_grid_pos(x, y);
+			for x in 0..w
+			{
+				let coord = HexCoord::from_offset_pos(x, y);
 				let height = map.sample_height(&coord);
 				let tile = NavTile {
 					coord,
@@ -79,7 +94,8 @@ impl NavData {
 			}
 		}
 	}
-	pub fn update_tile(&mut self, coord: &HexCoord, height: f32, move_cost: f32) {
+	pub fn update_tile(&mut self, coord: &HexCoord, height: f32, move_cost: f32)
+	{
 		let tile = &mut self.tiles[coord.to_index(self.map_width)];
 		tile.move_cost = move_cost;
 		tile.height = height;
@@ -87,14 +103,17 @@ impl NavData {
 }
 
 #[derive(Clone)]
-pub struct NavTile {
+pub struct NavTile
+{
 	pub height: f32,
 	pub move_cost: f32,
 	pub coord: HexCoord,
 }
 
-impl NavTile {
+impl NavTile
-	pub fn calculate_heuristic(&self, to: &HexCoord) -> OrderedFloat<f32> {
+{
+	pub fn calculate_heuristic(&self, to: &HexCoord) -> OrderedFloat<f32>
+	{
 		return (self.coord.distance(to) as f32).into();
 	}
 }

game/units/src/units_plugin.rs

@@ -1,9 +1,14 @@
 use std::collections::HashMap;
 
-use bevy::{ecs::world::CommandQueue, prelude::*, tasks::AsyncComputeTaskPool, utils::futures};
+use bevy::{
+	ecs::world::CommandQueue,
+	prelude::*,
+	tasks::{futures, AsyncComputeTaskPool},
+};
+use hex::prelude::*;
 use pathfinding::prelude::astar;
 use shared::{events::TileModifiedEvent, resources::TileUnderCursor, sets::GameplaySet};
-use world_generation::{hex_utils::HexCoord, prelude::Map, states::GeneratorState};
+use world_generation::{prelude::Map, states::GeneratorState};
 
 #[cfg(debug_assertions)]
 use crate::units_debug_plugin::UnitsDebugPlugin;
@@ -16,8 +21,10 @@ use crate::{
 
 pub struct UnitsPlugin;
 
-impl Plugin for UnitsPlugin {
+impl Plugin for UnitsPlugin
-	fn build(&self, app: &mut App) {
+{
+	fn build(&self, app: &mut App)
+	{
 		app.init_resource::<PathBatchId>();
 		app.add_plugins(UnitAssetPlugin);
 
@@ -36,15 +43,20 @@ impl Plugin for UnitsPlugin {
 	}
 }
 
-fn build_navdata(mut commands: Commands, map: Res<Map>) {
+fn build_navdata(mut commands: Commands, map: Res<Map>)
+{
 	let nav_data = NavData::build(&map);
 	commands.insert_resource(nav_data);
 }
 
-fn update_navdata(mut tile_updates: EventReader<TileModifiedEvent>, mut nav_data: ResMut<NavData>) {
+fn update_navdata(mut tile_updates: MessageReader<TileModifiedEvent>, mut nav_data: ResMut<NavData>)
-	for event in tile_updates.read() {
+{
-		match event {
+	for event in tile_updates.read()
-			TileModifiedEvent::HeightChanged(coord, new_height) => {
+	{
+		match event
+		{
+			TileModifiedEvent::HeightChanged(coord, new_height) =>
+			{
 				nav_data.update_tile(coord, *new_height, 1.0);
 			}
 			_ => (),
@@ -52,6 +64,7 @@ fn update_navdata(mut tile_updates: EventReader<TileModifiedEvent>, mut nav_data
 	}
 }
 
+#[allow(unused)]
 fn units_control(tile_under_cursor: Res<TileUnderCursor>) {}
 
 fn move_unit(
@@ -59,22 +72,27 @@ fn move_unit(
 	time: Res<Time>,
 	map: Res<Map>,
 	mut commands: Commands,
-) {
+)
-	for (mut t, mut path, entity) in units.iter_mut() {
+{
-		if path.1 >= path.0.len() {
+	for (mut t, mut path, entity) in units.iter_mut()
+	{
+		if path.1 >= path.0.len()
+		{
 			commands.entity(entity).remove::<Path>();
 			continue;
 		}
 		let p = path.0[path.1];
 		let d = p - t.translation;
-		if d.length() < 0.1 {
+		if d.length() < 0.1
+		{
 			path.1 += 1;
 			continue;
 		}
 		let vel = d.normalize() * 10.0 * time.delta_secs();
 		t.translation += vel;
 		let coord = HexCoord::from_world_pos(t.translation);
-		if map.is_in_bounds(&coord) {
+		if map.is_in_bounds(&coord)
+		{
 			t.translation.y = map.sample_height(&coord);
 		}
 	}
@@ -86,22 +104,28 @@ fn dispatch_path_requests(
 	nav_data: Res<NavData>,
 	mut batch_id: ResMut<PathBatchId>,
 	mut commands: Commands,
-) {
+)
-	if units.is_empty() {
+{
+	if units.is_empty()
+	{
 		return;
 	}
 	let mut groups: HashMap<HexCoord, Vec<PathRequest>> = HashMap::new();
 
 	#[cfg(feature = "tracing")]
 	let _group_span = info_span!("Grouping").entered();
-	for (transform, target, entity) in units.iter() {
+	for (transform, target, entity) in units.iter()
+	{
 		let req = PathRequest {
 			entity,
 			from: HexCoord::from_world_pos(transform.translation),
 		};
-		if let Some(group) = groups.get_mut(&target.0) {
+		if let Some(group) = groups.get_mut(&target.0)
+		{
 			group.push(req);
-		} else {
+		}
+		else
+		{
 			groups.insert(target.0, vec![req]);
 		}
 	}
@@ -109,11 +133,13 @@ fn dispatch_path_requests(
 	drop(_group_span);
 
 	let pool = AsyncComputeTaskPool::get();
-	for (target, units) in groups {
+	for (target, units) in groups
+	{
 		let id = batch_id.0;
 		batch_id.0 += 1;
 
-		for req in &units {
+		for req in &units
+		{
 			commands
 				.entity(req.entity)
 				.insert(PathTaskPending(id))
@@ -132,17 +158,21 @@ fn dispatch_path_requests(
 		let batch_task = pool.spawn(async move {
 			let mut i = 0;
 			let mut queue = CommandQueue::default();
-			for entitiy_req in req.entities {
+			for entitiy_req in req.entities
+			{
 				let dst = req.destination[i];
 				i += 1;
 				#[cfg(feature = "tracing")]
 				let _path_span = info_span!("Path Finding").entered();
-				if let Some(path) = calculate_path(&entitiy_req.from, &dst, &local_nav_data) {
+				if let Some(path) = calculate_path(&entitiy_req.from, &dst, &local_nav_data)
+				{
 					queue.push(move |world: &mut World| {
 						let mut unit_e = world.entity_mut(entitiy_req.entity);
 
-						if let Some(pending_task) = unit_e.get::<PathTaskPending>() {
+						if let Some(pending_task) = unit_e.get::<PathTaskPending>()
-							if pending_task.0 == id {
+						{
+							if pending_task.0 == id
+							{
 								unit_e.insert(path);
 								unit_e.remove::<PathTaskPending>();
 							}
@@ -150,7 +180,8 @@ fn dispatch_path_requests(
 					});
 				}
 			}
-			if queue.is_empty() {
+			if queue.is_empty()
+			{
 				return None;
 			}
 			return Some(queue);
@@ -159,26 +190,36 @@ fn dispatch_path_requests(
 	}
 }
 
-fn get_end_points(coord: &HexCoord, count: usize, map: &Map) -> Vec<HexCoord> {
+fn get_end_points(coord: &HexCoord, count: usize, map: &Map) -> Vec<HexCoord>
+{
 	let mut result = Vec::with_capacity(count);
-	if count == 1 {
+	if count == 1
+	{
 		return vec![*coord];
 	}
 	result.push(*coord);
 	let mut r = 1;
-	while result.len() < count {
+	while result.len() < count
+	{
 		let tiles = HexCoord::select_ring(coord, r);
 		let needed = count - result.len();
-		if needed >= tiles.len() {
+		if needed >= tiles.len()
-			for t in tiles {
+		{
-				if map.is_in_bounds(&t) {
+			for t in tiles
+			{
+				if map.is_in_bounds(&t)
+				{
 					result.push(t);
 				}
 			}
-		} else {
+		}
-			for i in 0..needed {
+		else
+		{
+			for i in 0..needed
+			{
 				let t = tiles[i];
-				if map.is_in_bounds(&t) {
+				if map.is_in_bounds(&t)
+				{
 					result.push(t);
 				}
 			}
@@ -189,10 +230,14 @@ fn get_end_points(coord: &HexCoord, count: usize, map: &Map) -> Vec<HexCoord> {
 	return result;
 }
 
-fn resolve_path_task(mut tasks: Query<(&mut PathTask, Entity)>, mut commands: Commands) {
+fn resolve_path_task(mut tasks: Query<(&mut PathTask, Entity)>, mut commands: Commands)
-	for (mut task, entity) in tasks.iter_mut() {
+{
-		if let Some(c) = futures::check_ready(&mut task.0) {
+	for (mut task, entity) in tasks.iter_mut()
-			if let Some(mut queue) = c {
+	{
+		if let Some(c) = futures::check_ready(&mut task.0)
+		{
+			if let Some(mut queue) = c
+			{
 				commands.append(&mut queue);
 			}
 			commands.entity(entity).despawn();
@@ -200,32 +245,38 @@ fn resolve_path_task(mut tasks: Query<(&mut PathTask, Entity)>, mut commands: Co
 	}
 }
 
-fn calculate_path(from: &HexCoord, to: &HexCoord, nav: &NavData) -> Option<Path> {
+fn calculate_path(from: &HexCoord, to: &HexCoord, nav: &NavData) -> Option<Path>
+{
 	let path = astar(
 		from,
 		|n| nav.get_neighbors(n),
 		|n| nav.get(n).calculate_heuristic(to),
 		|n| n == to,
 	);
-	if let Some((nodes, _cost)) = path {
+	if let Some((nodes, _cost)) = path
+	{
 		let result: Vec<_> = nodes.iter().map(|f| f.to_world(nav.get_height(f))).collect();
 		return Some(Path(result, 1));
 	}
 	return None;
 }
 
-struct PathRequest {
+struct PathRequest
+{
 	pub entity: Entity,
 	pub from: HexCoord,
 }
 
-struct BatchPathRequest {
+struct BatchPathRequest
+{
 	pub entities: Vec<PathRequest>,
 	pub destination: Vec<HexCoord>,
 }
 
-impl BatchPathRequest {
+impl BatchPathRequest
-	pub fn new(entities: Vec<PathRequest>, dst: Vec<HexCoord>) -> Self {
+{
+	pub fn new(entities: Vec<PathRequest>, dst: Vec<HexCoord>) -> Self
+	{
 		return Self {
 			destination: dst,
 			entities,

rust-toolchain.toml

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

rustfmt.toml

@@ -1,4 +1,3 @@
 hard_tabs = true
 max_width = 120
 brace_style = "AlwaysNextLine"
-control_brace_style = "AlwaysNextLine"