wow-navmesh 0.1.0__tar.gz

wow_navmesh-0.1.0/.gitattributes

@@ -0,0 +1,6 @@
+* text=auto eol=lf
+
+*.bat text eol=crlf
+*.dll binary
+*.pyd binary
+*.so binary

wow_navmesh-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install wow-navmesh and test dependencies
+        run: pip install . pytest
+
+      - name: Run tests
+        run: pytest -v

wow_navmesh-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,58 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build_wheels:
+    runs-on: windows-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.21
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-windows
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # required for PyPI Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          path: dist
+          merge-multiple: true
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: sdist
+          path: dist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

wow_navmesh-0.1.0/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+wheelhouse/
+.venv/
+venv/
+.build-venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Compiled extension modules
+*.so
+*.pyd
+*.dll
+
+# CMake / native build output
+cmake-build-*/
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+CTestTestfile.cmake
+_deps/
+out/
+*.obj
+*.o
+*.lib
+*.exp
+*.pdb
+*.ilk
+
+# Visual Studio
+.vs/
+*.vcxproj.user
+Debug/
+Release/
+x64/
+x86/
+out/
+
+# OS cruft
+.DS_Store
+Thumbs.db

wow_navmesh-0.1.0/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "extern/recastnavigation"]
+	path = extern/recastnavigation
+	url = https://github.com/recastnavigation/recastnavigation

wow_navmesh-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12.9

wow_navmesh-0.1.0/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## [0.1.0] - Unreleased
+
+Initial public release.
+
+- `NavMesh` binding (nanobind) over Detour's `dtNavMesh`/`dtNavMeshQuery`, for loading
+  TrinityCore/AzerothCore `.mmap`/`.mmtile` files and running `find_path()`.
+- Detour sources vendored as a git submodule against upstream recastnavigation `v1.6.0`,
+  built with `DT_POLYREF64` to match TrinityCore/AzerothCore's mmap layout (configurable
+  via the `WOW_NAVMESH_POLYREF64` CMake option / environment variable).
+- Tile layout validation: `load_map()` raises a clear `RuntimeError` when a tile's
+  on-disk size doesn't match the dtPolyRef width this build targets, instead of silently
+  misreading it.
+- Type stubs (`__init__.pyi`, `py.typed`) and a pytest suite (real-mmaps tests gated by
+  `WOW_NAVMESH_TEST_MMAPS`).

wow_navmesh-0.1.0/CLAUDE.md

@@ -0,0 +1,92 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+Python bindings (via nanobind) around Detour's `dtNavMesh`/`dtNavMeshQuery` from
+recastnavigation, scoped specifically to reading and pathfinding over the
+`.mmap`/`.mmtile` navmesh files produced by TrinityCore/AzerothCore for WoW 3.3.5a. It
+only wraps Detour's *query* engine — it does not build navmeshes (that's Recast/the
+core's own mmap generator).
+
+Windows x64 only. Non-Windows and 32-bit builds are rejected at CMake configure time
+(`CMakeLists.txt`).
+
+## Build system
+
+- `scikit-build-core` + `nanobind`, driven from `pyproject.toml`/`CMakeLists.txt`.
+- Detour's sources are vendored as a git submodule at `extern/recastnavigation/`
+  (pinned to `v1.6.0`) — must be initialized (`git submodule update --init --recursive`,
+  or clone with `--recursive`) before any build works.
+- Requires MSVC ("Desktop development with C++" workload). CMake/Ninja come from pip.
+
+Common commands (PowerShell):
+
+```powershell
+pip install .                        # build + install the extension
+pip install -e . --no-build-isolation  # editable install for iterative dev
+pip install pytest
+pytest                                # run the test suite
+pytest tests/test_navmesh.py::test_repr_and_initial_state  # single test
+```
+
+Building against a plain (non-TrinityCore/AzerothCore) Detour navmesh: set
+`WOW_NAVMESH_POLYREF64=OFF` before installing (`$env:WOW_NAVMESH_POLYREF64 = "OFF"`).
+This is a CMake option that toggles a compile define (`DT_POLYREF64`) — it changes the
+binary's expected on-disk tile layout, not just a runtime flag, so it requires a rebuild.
+
+## Architecture
+
+Everything lives in one file: `src/bindings.cpp`. It defines a single C++ `NavMesh`
+class exposed to Python as `_wow_navmesh.NavMesh`, then re-exported as
+`wow_navmesh.NavMesh` in `src/wow_navmesh/__init__.py`.
+
+Key mechanics inside `NavMesh`:
+
+- **`load_map(map_id)`**: reads `{map_id:03}.mmap` for the `dtNavMeshParams` header,
+  then scans a sparse 64x64 grid of `{map_id:03}{x:02}{y:02}.mmtile` files, validating
+  each one's own `MmapTileHeader` (magic/version) before handing its payload to
+  `dtNavMesh::addTile()`.
+- **The `DT_POLYREF64` layout check (`checkTileLayout`)**: TrinityCore/AzerothCore build
+  their mmap generator with `DT_POLYREF64`, widening `dtPolyRef` from 32 to 64 bits.
+  That changes the size of `dtLink` (which embeds a `dtPolyRef`), and thus the byte
+  offset of every tile section after it — but doesn't change the magic/version Detour
+  itself checks, so a mismatched build would otherwise silently misread tiles instead of
+  failing loudly. `expectedTileSize()` recomputes a tile's expected serialized size from
+  its `dtMeshHeader` counts (mirroring `DetourNavMeshBuilder`'s own section-size math)
+  under both possible `dtLink` sizes, and `checkTileLayout()` compares that against the
+  file's actual size to detect and name a layout mismatch before it corrupts anything.
+  If you touch this logic, keep it in sync with upstream `DetourNavMeshBuilder.cpp`.
+- **Coordinate swap**: `.mmap`/`.mmtile` files store coordinates as `(y, z, x)`; the
+  public API always uses WoW's `(x, y, z)` order. The swap happens only at the
+  `find_path()` boundary (both on the way in for start/end points and on the way out for
+  result points) — nowhere else in the codebase needs to think about it.
+- **RAII ownership**: `DtNavMeshPtr`/`DtBuffer` (custom deleters over `dtFreeNavMesh`/
+  `dtFree`) ensure a throw partway through `load_map()` can't leak the in-progress mesh
+  or a tile buffer that `addTile()` didn't take ownership of. `load_map()` calls
+  `free_map()` first, so a failed load leaves the previous map's state, not a partial one.
+- Nearest-poly search extents (50 units/axis) and the internal path-poly buffer (512
+  polys) inside `find_path()` are fixed constants, not exposed as parameters.
+
+Python-side surface is thin: `src/wow_navmesh/__init__.py` just re-exports `NavMesh` and
+resolves `__version__` via `importlib.metadata`. Type stubs live in
+`src/wow_navmesh/__init__.pyi` (kept in sync manually with the nanobind bindings) and the
+package ships `py.typed`.
+
+## Tests
+
+`tests/test_navmesh.py` has two tiers:
+
+- No-mmap-data tests (construction, error paths, context manager) run in CI as-is.
+- A second tier exercises real `find_path()` behavior against an actual
+  TrinityCore/AzerothCore mmaps directory, gated behind the `WOW_NAVMESH_TEST_MMAPS`
+  env var (skipped otherwise). Point it at a directory containing e.g. `000.mmap` +
+  `0002239.mmtile` for Eastern Kingdoms to enable that tier locally.
+
+## CI/release
+
+- `.github/workflows/ci.yml`: runs the test suite on `windows-latest` across Python
+  3.10–3.13 on every push/PR to `main`.
+- `.github/workflows/release.yml`: on `v*` tags, builds `win_amd64` wheels via
+  `cibuildwheel` and an sdist, then publishes to PyPI via Trusted Publishing (OIDC).

wow_navmesh-0.1.0/CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.15...3.27)
+project(wow_navmesh LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if (NOT SKBUILD)
+  message(WARNING "This CMakeLists.txt is meant to be driven by scikit-build-core (pip install).")
+endif()
+
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+# wow-navmesh only targets 64-bit Windows (matching TrinityCore/AzerothCore's own
+# mmap tooling and the only platform prebuilt wheels are published for).
+if (NOT WIN32)
+  message(FATAL_ERROR
+    "wow-navmesh only supports Windows. Building on '${CMAKE_SYSTEM_NAME}' is not supported.")
+endif()
+
+if (CMAKE_SIZEOF_VOID_P EQUAL 4)
+  message(FATAL_ERROR
+    "wow-navmesh only supports 64-bit Python interpreters. "
+    "A 32-bit build was detected (CMAKE_SIZEOF_VOID_P=4); reconfigure with a 64-bit toolchain/interpreter.")
+endif()
+
+set(DETOUR_SOURCE_DIR
+  "${PROJECT_SOURCE_DIR}/extern/recastnavigation/Detour"
+  CACHE PATH "Path to the Detour library source tree (Include/ and Source/)")
+
+if (NOT EXISTS "${DETOUR_SOURCE_DIR}/Include/DetourNavMesh.h")
+  message(FATAL_ERROR
+    "Detour sources not found at '${DETOUR_SOURCE_DIR}'. "
+    "The recastnavigation submodule looks uninitialized. Run:\n"
+    "    git submodule update --init --recursive\n"
+    "or point DETOUR_SOURCE_DIR at an existing Detour/ checkout (Include/ and Source/).")
+endif()
+
+# TrinityCore/AzerothCore mmap tiles are generated with DT_POLYREF64 enabled (a wider
+# dtPolyRef changes the on-disk size of dtLink, and therefore every tile's byte layout).
+# Keep this ON to read those tiles; turning it OFF targets a plain Detour navmesh built
+# without that define instead. See src/bindings.cpp for the layout mismatch this guards.
+option(WOW_NAVMESH_POLYREF64
+  "Build against the DT_POLYREF64 tile layout used by TrinityCore/AzerothCore mmaps" ON)
+
+find_package(Python 3.10
+  REQUIRED COMPONENTS Interpreter Development.Module)
+
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -c "import nanobind; print(nanobind.cmake_dir())"
+  OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE NB_DIR)
+list(APPEND CMAKE_PREFIX_PATH "${NB_DIR}")
+find_package(nanobind CONFIG REQUIRED)
+
+nanobind_add_module(
+  _wow_navmesh
+  src/bindings.cpp
+  "${DETOUR_SOURCE_DIR}/Source/DetourAlloc.cpp"
+  "${DETOUR_SOURCE_DIR}/Source/DetourAssert.cpp"
+  "${DETOUR_SOURCE_DIR}/Source/DetourCommon.cpp"
+  "${DETOUR_SOURCE_DIR}/Source/DetourNavMesh.cpp"
+  "${DETOUR_SOURCE_DIR}/Source/DetourNavMeshBuilder.cpp"
+  "${DETOUR_SOURCE_DIR}/Source/DetourNavMeshQuery.cpp"
+  "${DETOUR_SOURCE_DIR}/Source/DetourNode.cpp"
+)
+
+target_include_directories(_wow_navmesh PRIVATE "${DETOUR_SOURCE_DIR}/Include")
+
+if (WOW_NAVMESH_POLYREF64)
+  target_compile_definitions(_wow_navmesh PRIVATE DT_POLYREF64 WOW_NAVMESH_POLYREF64=1)
+else()
+  target_compile_definitions(_wow_navmesh PRIVATE WOW_NAVMESH_POLYREF64=0)
+endif()
+
+install(TARGETS _wow_navmesh LIBRARY DESTINATION wow_navmesh)

wow_navmesh-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.1
+Name: wow-navmesh
+Version: 0.1.0
+Summary: Python bindings for Detour (recastnavigation) navmesh pathfinding over TrinityCore/AzerothCore mmaps
+Keywords: recastnavigation,detour,navmesh,pathfinding,trinitycore,azerothcore,wow
+Author: srounet
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Libraries
+Project-URL: Homepage, https://github.com/srounet/wow-navmesh
+Project-URL: Repository, https://github.com/srounet/wow-navmesh
+Project-URL: Issues, https://github.com/srounet/wow-navmesh/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# wow-navmesh
+
+Python bindings (via [nanobind](https://github.com/wjakob/nanobind)) for
+[Detour](https://github.com/recastnavigation/recastnavigation), the navmesh query engine
+from recastnavigation — scoped to pathfinding over the `.mmap`/`.mmtile` navmesh files
+generated by TrinityCore/AzerothCore for World of Warcraft 3.3.5a.
+
+This wraps Detour's *query* engine (`dtNavMesh` / `dtNavMeshQuery`) only. It does not
+build navmeshes — that's Recast, and TrinityCore/AzerothCore's own mmap generator tools
+already produce the `.mmap`/`.mmtile` files this library reads.
+
+## Install
+
+```bash
+pip install wow-navmesh
+```
+
+Prebuilt wheels are published for 64-bit CPython 3.10–3.13 on Windows (x64) only. No
+compiler needed for a normal install. Linux and macOS are not supported.
+
+## Quickstart
+
+```python
+import wow_navmesh as wn
+
+nm = wn.NavMesh(r"C:\path\to\mmaps")
+nm.load_map(0)  # 0 = Eastern Kingdoms
+
+path = nm.find_path((x1, y1, z1), (x2, y2, z2))
+for x, y, z in path:
+    print(x, y, z)
+```
+
+`NavMesh` also works as a context manager, freeing the loaded map on exit:
+
+```python
+with wn.NavMesh(r"C:\path\to\mmaps") as nm:
+    nm.load_map(0)
+    ...
+```
+
+Coordinates are `(x, y, z)` in WoW world-coordinate order everywhere in this API. The
+`.mmap`/`.mmtile` files store them as `(y, z, x)`; the swap happens internally at the
+`find_path()` boundary, so callers never need to think about it.
+
+## API
+
+- `NavMesh(mmaps_path: str)` — bind to a directory of `.mmap`/`.mmtile` files.
+- `.load_map(map_id: int)` — load the navmesh for a map id, replacing any map currently
+  loaded. Raises `RuntimeError` if the files are missing, truncated, or were built for a
+  different `dtPolyRef` layout than this build targets (see below).
+- `.free_map()` — release the currently loaded map.
+- `.find_path(start, end, max_points=256) -> list[(x, y, z)]` — the straight path
+  between two points, or `[]` if none was found. Raises `RuntimeError` if no map is
+  loaded, `ValueError` if `max_points <= 0`.
+- `.is_loaded`, `.map_id`, `.mmaps_path` — read-only properties.
+
+Full type stubs ship with the package (`py.typed`).
+
+## A note on `DT_POLYREF64`
+
+TrinityCore/AzerothCore build their mmap generator with Detour's `DT_POLYREF64` option
+enabled, which widens `dtPolyRef` from 32 to 64 bits. That changes the on-disk byte
+layout of every tile (`dtLink`, which embeds a `dtPolyRef`, changes size — and every
+section of a tile after it shifts as a result). Published wheels are built with
+`DT_POLYREF64` on, matching TrinityCore/AzerothCore's own tools; `load_map()` checks
+each tile's layout against what it expects and raises a clear `RuntimeError` (naming the
+mismatch) rather than silently misreading a tile built the other way.
+
+Building from source against a plain Detour navmesh (not TrinityCore/AzerothCore's)?
+Set `WOW_NAVMESH_POLYREF64=OFF` before installing:
+
+```powershell
+$env:WOW_NAVMESH_POLYREF64 = "OFF"
+pip install --no-binary wow-navmesh wow-navmesh
+```
+
+wow-navmesh only supports 64-bit Windows Python interpreters; 32-bit builds and
+non-Windows platforms are rejected at configure time.
+
+## Building from source
+
+Requirements:
+
+- Windows, 64-bit CPython 3.10–3.13.
+- A C++ compiler with MSVC support — the
+  [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/) (or full
+  Visual Studio) "Desktop development with C++" workload. CMake and Ninja are pulled in
+  automatically by `pip` and don't need to be installed separately.
+
+```powershell
+git clone --recursive https://github.com/srounet/wow-navmesh
+cd wow-navmesh
+pip install .
+```
+
+The `--recursive` clone (or a `git submodule update --init --recursive` afterwards) is
+required — Detour's sources are vendored as a git submodule under
+`extern/recastnavigation/`, pinned to upstream tag `v1.6.0`.
+
+Run the tests with `pip install pytest && pytest`. A second tier of tests exercises
+`find_path()` against a real mmaps directory; point `WOW_NAVMESH_TEST_MMAPS` at one to
+enable it:
+
+```powershell
+$env:WOW_NAVMESH_TEST_MMAPS = "C:\path\to\mmaps"
+pytest
+```
+
+## Known limitations
+
+- Only verified against TrinityCore/AzerothCore mmaps for WoW 3.3.5a. The mmap format
+  may differ across core versions or forks; nothing here has been tested against those.
+- The nearest-poly search extents (50 units on each axis) and the internal path-buffer
+  size (512 polygons) used by `find_path()` are currently fixed, not configurable.
+- License: TBD (recastnavigation/Detour itself is zlib-licensed; its notice is included
+  under `extern/recastnavigation/`).
+
+## Acknowledgments
+
+- [recastnavigation](https://github.com/recastnavigation/recastnavigation) by Mikko
+  Mononen and contributors.
+- [nanobind](https://github.com/wjakob/nanobind) by Wenzel Jakob.

wow_navmesh-0.1.0/README.md

@@ -0,0 +1,123 @@
+# wow-navmesh
+
+Python bindings (via [nanobind](https://github.com/wjakob/nanobind)) for
+[Detour](https://github.com/recastnavigation/recastnavigation), the navmesh query engine
+from recastnavigation — scoped to pathfinding over the `.mmap`/`.mmtile` navmesh files
+generated by TrinityCore/AzerothCore for World of Warcraft 3.3.5a.
+
+This wraps Detour's *query* engine (`dtNavMesh` / `dtNavMeshQuery`) only. It does not
+build navmeshes — that's Recast, and TrinityCore/AzerothCore's own mmap generator tools
+already produce the `.mmap`/`.mmtile` files this library reads.
+
+## Install
+
+```bash
+pip install wow-navmesh
+```
+
+Prebuilt wheels are published for 64-bit CPython 3.10–3.13 on Windows (x64) only. No
+compiler needed for a normal install. Linux and macOS are not supported.
+
+## Quickstart
+
+```python
+import wow_navmesh as wn
+
+nm = wn.NavMesh(r"C:\path\to\mmaps")
+nm.load_map(0)  # 0 = Eastern Kingdoms
+
+path = nm.find_path((x1, y1, z1), (x2, y2, z2))
+for x, y, z in path:
+    print(x, y, z)
+```
+
+`NavMesh` also works as a context manager, freeing the loaded map on exit:
+
+```python
+with wn.NavMesh(r"C:\path\to\mmaps") as nm:
+    nm.load_map(0)
+    ...
+```
+
+Coordinates are `(x, y, z)` in WoW world-coordinate order everywhere in this API. The
+`.mmap`/`.mmtile` files store them as `(y, z, x)`; the swap happens internally at the
+`find_path()` boundary, so callers never need to think about it.
+
+## API
+
+- `NavMesh(mmaps_path: str)` — bind to a directory of `.mmap`/`.mmtile` files.
+- `.load_map(map_id: int)` — load the navmesh for a map id, replacing any map currently
+  loaded. Raises `RuntimeError` if the files are missing, truncated, or were built for a
+  different `dtPolyRef` layout than this build targets (see below).
+- `.free_map()` — release the currently loaded map.
+- `.find_path(start, end, max_points=256) -> list[(x, y, z)]` — the straight path
+  between two points, or `[]` if none was found. Raises `RuntimeError` if no map is
+  loaded, `ValueError` if `max_points <= 0`.
+- `.is_loaded`, `.map_id`, `.mmaps_path` — read-only properties.
+
+Full type stubs ship with the package (`py.typed`).
+
+## A note on `DT_POLYREF64`
+
+TrinityCore/AzerothCore build their mmap generator with Detour's `DT_POLYREF64` option
+enabled, which widens `dtPolyRef` from 32 to 64 bits. That changes the on-disk byte
+layout of every tile (`dtLink`, which embeds a `dtPolyRef`, changes size — and every
+section of a tile after it shifts as a result). Published wheels are built with
+`DT_POLYREF64` on, matching TrinityCore/AzerothCore's own tools; `load_map()` checks
+each tile's layout against what it expects and raises a clear `RuntimeError` (naming the
+mismatch) rather than silently misreading a tile built the other way.
+
+Building from source against a plain Detour navmesh (not TrinityCore/AzerothCore's)?
+Set `WOW_NAVMESH_POLYREF64=OFF` before installing:
+
+```powershell
+$env:WOW_NAVMESH_POLYREF64 = "OFF"
+pip install --no-binary wow-navmesh wow-navmesh
+```
+
+wow-navmesh only supports 64-bit Windows Python interpreters; 32-bit builds and
+non-Windows platforms are rejected at configure time.
+
+## Building from source
+
+Requirements:
+
+- Windows, 64-bit CPython 3.10–3.13.
+- A C++ compiler with MSVC support — the
+  [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/) (or full
+  Visual Studio) "Desktop development with C++" workload. CMake and Ninja are pulled in
+  automatically by `pip` and don't need to be installed separately.
+
+```powershell
+git clone --recursive https://github.com/srounet/wow-navmesh
+cd wow-navmesh
+pip install .
+```
+
+The `--recursive` clone (or a `git submodule update --init --recursive` afterwards) is
+required — Detour's sources are vendored as a git submodule under
+`extern/recastnavigation/`, pinned to upstream tag `v1.6.0`.
+
+Run the tests with `pip install pytest && pytest`. A second tier of tests exercises
+`find_path()` against a real mmaps directory; point `WOW_NAVMESH_TEST_MMAPS` at one to
+enable it:
+
+```powershell
+$env:WOW_NAVMESH_TEST_MMAPS = "C:\path\to\mmaps"
+pytest
+```
+
+## Known limitations
+
+- Only verified against TrinityCore/AzerothCore mmaps for WoW 3.3.5a. The mmap format
+  may differ across core versions or forks; nothing here has been tested against those.
+- The nearest-poly search extents (50 units on each axis) and the internal path-buffer
+  size (512 polygons) used by `find_path()` are currently fixed, not configurable.
+- License: TBD (recastnavigation/Detour itself is zlib-licensed; its notice is included
+  under `extern/recastnavigation/`).
+
+## Acknowledgments
+
+- [recastnavigation](https://github.com/recastnavigation/recastnavigation) by Mikko
+  Mononen and contributors.
+- [nanobind](https://github.com/wjakob/nanobind) by Wenzel Jakob.

wow_navmesh-0.1.0/extern/recastnavigation/.editorconfig

@@ -0,0 +1,12 @@
+# editorconfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_size = 4
+indent_style = tab
+
+[*.yml]
+indent_size = 2
+indent_style = space

wow_navmesh-0.1.0/extern/recastnavigation/.git

@@ -0,0 +1 @@
+gitdir: ../../.git/modules/extern/recastnavigation