bevy_state_plugin_generator 1.4.4

A build-dependency that generates a Bevy State Plugin from a simple state definition.
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

# State-Plugin generator

Generates a bunch of hierarchical states (structs and enums, using `State`
and `SubState`) from a simple DSL and sets up their relationships
in a `Plugin`.

## Probably do not use

I made this without checking if and/or how it would be a good idea.

## versions

| bevy   | this thing |
| ------ | ---------- |
| 0.15.0 | 1.2.0      |
| 0.16.0 | 1.3.0      |
| 0.17.0 | 1.4.0      |

## usage

### single-file mode

Create a `states.rs` in `src/` and add the following comment at the top:

```rs
// bspg:
// Loading
// Ready { Menu Game }
// Exiting
```

Set up your `build.rs` like this:

```rust no_run
use bevy_state_plugin_generator::prelude::*;
fn main() {
  /// The [Default::default] configuration is:
  let config = PluginConfig {
    plugin_name: PluginName::new_struct("GeneratedStatesPlugin"),
    root_state_name: Some(Cow::from("GameState")),
    states_module_name: Cow::from("states"),
    naming_scheme: NamingScheme::Full,
    additional_derives: vec![],
  };
  update_template("src/states.rs", config)
    .expect("Failed to update template!");
}
```

### separate-file mode

Create a `states.txt` in `src/`:

```txt
// the root is implicit
Loading // comments go until the end of the line
Ready { Menu Game }                     // enum state
Exiting                                 // singleton
```

Set up your `build.rs` like this:

```rust no_run
use bevy_state_plugin_generator::prelude::*;
fn main() {
  /// The [Default::default] configuration is:
  let config = PluginConfig {
    plugin_name: PluginName::new_struct("GeneratedStatesPlugin"),
    root_state_name: Some(Cow::from("GameState")),
    states_module_name: Cow::from("states"),
    naming_scheme: NamingScheme::Full,
    additional_derives: vec![],
  };
  generate_plugin("src/states.txt", "src/generated_states.rs", config)
    .expect("Failed to generate plugin!");
}
```

And it will generate something like the following:

```rust no_run
use bevy::prelude::{App, AppExtStates};
pub mod states {
    use bevy::prelude::{States, SubStates, StateSet};
    #[derive(States, Hash, Default, Debug, Clone, PartialEq, Eq)]
    pub enum GameState { #[default] Loading, Ready, Exiting }
    #[derive(SubStates, Hash, Default, Debug, Clone, PartialEq, Eq)]
    #[source(GameState = GameState::Loading)]
    pub struct GameStateLoading;
    #[derive(SubStates, Hash, Default, Debug, Clone, PartialEq, Eq)]
    #[source(GameStateLoading = GameStateLoading)]
    pub struct GameStateLoadingConfigs;
    #[derive(SubStates, Hash, Default, Debug, Clone, PartialEq, Eq)]
    #[source(GameStateLoading = GameStateLoading)]
    pub struct GameStateLoadingAssets;
    #[derive(SubStates, Hash, Default, Debug, Clone, PartialEq, Eq)]
    #[source(GameState = GameState::Ready)]
    pub enum GameStateReady { #[default] Menu, Game }
}
pub struct GeneratedStatesPlugin;
impl bevy::app::Plugin for GeneratedStatesPlugin {
    fn build(&self, app: &mut App) {
        app.init_state::<states::GameState>();
    }
}
```

## naming

Consider the following sample:

```txt
PlayerState {
    Good
    BadState { OnFire InWater }
}
```

| none          | full                         | merge                   |
| ------------- | ---------------------------- | ----------------------- |
| `PlayerState` | `PlayerState`                | `PlayerState`           |
| `Good`        | `PlayerStateGood`            | `PlayerGoodState`       |
| `BadState`    | `PlayerStateBadState`        | `PlayerBadState`        |
| `OnFire`      | `PlayerStateBadStateOnFire`  | `PlayerBadOnFireState`  |
| `InWater`     | `PlayerStateBadStateInWater` | `PlayerBadInWaterState` |