ron_asset_manager 0.2.0

A dead simple crate to manage Ron based assets which depend on other assets.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

# ron asset manager

[![License: MIT or Apache 2.0](https://img.shields.io/badge/License-MIT%20or%20Apache2-blue.svg)](./LICENSE)
[![Crate](https://img.shields.io/crates/v/bevy_enoki.svg)](https://crates.io/crates/ron_asset_manager)

A dead simple crate to manage Ron based assets which depend
on other assets.

Assets can hot reload into a running game state. Use it to your
advantage!

#### **Any asset, that can be loaded from an asset path is supported!**

## Harness the power of external configuration.

`Shandle<T>` is a thin wrapper around `Handle<T>` that can be serialized by
behaving like a asset path in serialized form.

This crates provides the `RonAsset` derive macro, `RonAssetPlugin` and the `Shandle`.
The idea is to mark asset dependencies via attribute.


|          attribute |                                               what is does |
| -----------------: | ---------------------------------------------------------: |
|            `asset` |                                a single `Shandle<A>` field |
|        `asset_vec` |                                  a `Vec<Shandle<A>>` field |
|        `asset_map` |                            a `HashMap<K,Shandle<A>>` field |
|     `asset_struct` | A struct deriving `RonAsset` with its own asset attributes |
| `asset_struct_vec` |                                         a Vec of RonAssets |
| `asset_struct_map` |                                     a HashMap of RonAssets |

!Nested structs do not need to be assets themself. Checkout the `simple example`!

`cargo run --example simple`

## Example

Checkout the `simple` example. It loads a multi-sprite car with multiple tires each holding unique information
and assets.

```rust
#[derive(Asset, TypePath, RonAsset, Deserialize)]
pub struct Wizard{
    pub name: String,
    pub health: f32,
    #[asset]
    pub sprite: Shandle<Image>,
    #[asset_map]
    pub sounds: HashMap<String, Shandle<AudioSource>>,
    #[asset_vec]
    pub spells: Vec<Shandle<Spells>>,
    #[asset_struct]
    pub staff: Weapon,
}

#[derive(RonAsset, Deserialize)]
pub struct Weapon{
    pub damage: f32,
    pub cooldown: f32,
    #[asset]
    pub sprite: Shandle<Image>,
}

// add the provided plugin for your asset struct.
// this steps also initializes the asset for bevy.
fn build(&self, app: &mut App) {
    app.add_plugins(RonAssetPlugin::<Wizard>::default());
}

// that's all, time to use it
fn spawn_wizard(mut cmd: Commands, server: Res<AssetServer>){
    let wizard_handle: Handle<Wizard> = server.load("enemies/gandalf.ron")

    cmd.spawn((
        WizardSpawner(wizard_handle),
        SpawnCount(3),
        Transfrom::default(),
    ));
}

```

_gandalf.ron_:

```ron
(
    name: "Gandalf",
    health: 42069,
    sprite: "sprite/gandalf.png",
    sounds: {
        "death" : "audio/gandalf_rebirth.ogg",
        "hit"   : "audio/gandalf_hurt.ogg",
        "angry" : "audio/gandalf_calm.ogg",
    },
    spells: [
        "spells/light.ron",
        "spells/cloth_swap.ron",
    ],
    staff : (
        damage: 99,
        cooldown: 1,
        sprite: "staff.png"
    )
)
```