Fix docs

Signed-off-by: Michael X. Grey <[email protected]>

Author: mxgrey

README.md

@@ -17,44 +17,26 @@ There are several different categories of problems that bevy impulse sets out to
 # Helpful Links
 
  * [Introduction to workflows](https://docs.google.com/presentation/d/1_vJTyFKOB1T0ylCbp1jG72tn8AXYQOKgTGh9En9si-w/edit?usp=sharing)
+ * [Bevy Impulse Docs](https://docs.rs/bevy_impulse/latest/bevy_impulse/)
  * [Bevy Engine](https://bevyengine.org/)
  * [Bevy Cheat Book](https://bevy-cheatbook.github.io/)
  * [Rust Book](https://doc.rust-lang.org/stable/book/)
+ * [Install Rust](https://www.rust-lang.org/tools/install)
 
-# Experimenting
+# Compatibility
 
-### Install Rust
+Bevy Impulse is supported across several releases of Bevy:
 
-Follow [official guidelines](https://www.rust-lang.org/tools/install) to install the Rust language.
+| bevy | bevy_impulse |
+|------|--------------|
+|0.14  | 0.2          |
+|0.13  | 0.1          |
+|0.12  | 0.0.x        |
 
-### Get source code
-
-```
-$ git clone https://github.com/open-rmf/bevy_impulse
-```
-
-### Build
-
-To build the library simply go to the root directory of the repo and run
-
-```
-$ cargo build
-```
-
-### Test
-
-The library's tests can be run with
-
-```
-$ cargo test
-```
-
-### View Documentation
-
-Like most Rust projects, the library documentation is written into the source code and can be built and viewed with
-
-```
-$ cargo doc --open
-```
-
-After the first release of the library, the documentation will be hosted on docs.rs. We will update this README with a link to that documentation once it is ready.
+The `main` branch currently targets bevy version 0.12 (bevy impulse 0.0.x)
+so that new developments are still compatible for users of bevy 0.12. New features
+will be forward-ported as soon as possible. `main` will move forward to newer
+versions of bevy when we judge that enough of the ecosystem has finished migrating
+forward that there is no longer value in supporting old versions. In the future
+we may come up with a more concrete policy for this, and we are open to input on
+the matter.

src/lib.rs

@@ -15,7 +15,7 @@
  *
 */
 
-//! ![sense-think-act workflow](https://raw.githubusercontent.com/open-rmf/bevy_impulse/update_docs/assets/figures/sense-think-act_workflow.svg)
+//! ![sense-think-act workflow](https://raw.githubusercontent.com/open-rmf/bevy_impulse/main/assets/figures/sense-think-act_workflow.svg)
 //!
 //! Bevy impulse is an extension to the [Bevy](https://bevyengine.org) game
 //! engine that allows you to transform [bevy systems](https://bevyengine.org/learn/quick-start/getting-started/ecs/)

src/map.rs

@@ -29,14 +29,14 @@ use std::future::Future;
 pub struct MapDef<F>(F);
 
 /// Maps are used to perform simple transformations of data which do not require
-/// any direct [`World`] access or any persistent system state. They are more
-/// efficient than [`Service`] or [`Callback`] when suitable.
+/// any direct [`World`][4] access or any persistent system state. They are more
+/// efficient than [`Service`][5] or [`Callback`][6] when suitable.
 ///
 /// There are two kinds of functions that can be used as maps:
 /// * **Blocking**: A regular function with a single input and any output.
 ///   All system execution will be blocked while this is running, similar to flushing [`Commands`].
 /// * **Async**: A function that takes a single input and returns something that implements the [`Future`] trait.
-///   The [`Future`] will be executed in the [`AsyncComputeTaskPool`] unless the `single_threaded_async` feature is active.
+///   The [`Future`] will be executed in the [`AsyncComputeTaskPool`][7] unless the `single_threaded_async` feature is active.
 ///
 /// If you want to insert a map into a workflow or impulse chain, you can pass your function into one of the following,
 /// depending on whether you want blocking or async:
@@ -46,7 +46,7 @@ pub struct MapDef<F>(F);
 ///   * [`Builder::create_map_block`](crate::Builder::create_map_block)
 ///   * [`Impulse::map_block`](crate::Impulse::map_block)
 /// * **Async**
-///   * [`Chain::map_async`](crate::Chain:::map_async)
+///   * [`Chain::map_async`](crate::Chain::map_async)
 ///   * [`Chain::map_async_node`](crate::Chain::map_async_node)
 ///   * [`Builder::create_map_async`](crate::Builder::create_map_async)
 ///   * [`Impulse::map_async`](crate::Impulse::map_async)
@@ -65,10 +65,10 @@ pub struct MapDef<F>(F);
 /// [1]: AsMap::as_map
 /// [2]: IntoBlockingMap::into_blocking_map
 /// [3]: IntoAsyncMap::into_async_map
-/// [World]: bevy_ecs::prelude::World
-/// [Service]: crate::Service
-/// [Callback]: crate::Callback
-/// [AsyncComputeTaskPool]: bevy_tasks::AsyncComputeTaskPool
+/// [4]: bevy_ecs::prelude::World
+/// [5]: crate::Service
+/// [6]: crate::Callback
+/// [7]: bevy_tasks::AsyncComputeTaskPool
 #[allow(clippy::wrong_self_convention)]
 pub trait AsMap<M> {
     type MapType;