# Micro Game Macros

[![docs.rs](https://img.shields.io/docsrs/micro_games_macros?style=for-the-badge)](https://docs.rs/micro_games_macros)
[![Crates.io](https://img.shields.io/crates/v/micro_games_macros?style=for-the-badge)](https://crates.io/crates/micro_games_macros)

A collection of utility macros for building games. While this library should theoretically work with
any version of Bevy that includes the required traits and structs for a given macro, it is worth checking the
version of bevy listed as a dev dependency in `Cargo.toml`, as that will be the version tested against.

This works because the library does not directly depend on bevy, but instead just generates fully qualified paths
to derives, traits, and structs that will resolve to the version of Bevy used in your downstream project

**Current Version Support: 0.6.x -> Bevy 0.14**

## Macros

For executable examples, visit the rustdoc and/or read the doctests in `src/lib.rs`

### JSON Loader

Generate a Bevy asset loader for a given asset, supporting JSON files that define a single instance of that asset type,
or a
list of that asset type. Instances of an asset need to be identifiable, though the property that is used to identify a
particular
asset is customisable

```rust
#[derive(JsonLoader, TypePath, TypeUuid, Serialize, Deserialize, Asset)]
#[loader(
    extension = "asset.json", uuid = "00000000-0000-0000-0000-000000000000",
    storage = inner_module::SimpleAssetLocator,
    asset_name = some_asset_prop, index_name = set_of_assets
)]
#[uuid = "00000000-0000-0000-0000-000000000001"]
pub struct MyAsset {
    /// The asset identifier needs to implement [std::fmt::Display]
    #[asset_id]
    uniq_ident: usize,
}
```

### Asset System

Generate a set of structs and systems for managed loading in a Bevy game

```rust
use bevy::prelude::{Image, Res, Resource};
use micro_games_macros::asset_system;

#[asset_system]
pub struct AssetHandles {
    my_asset: Image,
}

pub fn loading_system(mut loader: AssetHandlesLoader) {
    loader.load_my_asset("path/to/asset.png", "Asset");
}
pub fn use_asset_system(assets: Res<AssetHandles>) {
    let handle = assets.my_asset("Asset");
}
```

### From Inner

Derive an impl of `From<T>` for structs that wrap a single inner type (Tuple and Named Property structs are supported)

```rust
use micro_game_macros::FromInner;

#[derive(FromInner)]
struct MyType(usize);

fn example() {
    let value = MyType::from(123usize);
}
```

### Kayak Widget

A simple derive for Kayak UI's "Widget" trait

```rust
use micro_game_macros::Widget;

#[derive(Widget)]
struct MyComponent;

// ... Other Kayak Setup ...

```

### Tag Finder

Create a system param for checking whether an entity has one of a specified number of tags. The tag finder will also
create the tag components, which can use either table or sparse storage

```rust
use micro_games_macros::tag_finder;

#[tag_finder]
pub struct TagFinder {
    player: Player,
    item: Item,
    #[sparse]
    hover: Hover,
}
```