Crate bevy_proto_typetag 

Serializable entity configuration for the Bevy game engine.

This crate provides several abstractions for specifying serializable entities and components:

• The ProtoComponent trait provides methods to load components from assets.
• The ProtoDeserializer trait describes component deserialization.
• ProtoPlugin provides configuration for asset loading.

Examples

Define a serialized prototype:

# assets/prototypes/simple-enemy.yaml
name: "Simple Enemy"
components:
    - type: Enemy
    - type: Attack
      value:
        damage: 10

Implement ProtoComponent for the component types:

use bevy::prelude::*;
use bevy_proto_typetag::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Clone, Serialize, Deserialize, ProtoComponent, Component)]
struct Enemy;

#[derive(Clone, Serialize, Deserialize, ProtoComponent, Component)]
struct Attack {
    damage: u16
}

Add the plugin:

use bevy::prelude::*;
use bevy_proto_typetag::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
   
        .add_plugin(ProtoPlugin {
            options: Some(ProtoDataOptions {
               // You can also change the prototype directories here
               directories: vec![String::from("assets/prototypes")],
               // And specify whether you want the prototype files to be recursively loaded
               recursive_loading: false,
               // You can also update the allowed extensions within those directories
               extensions: Some(vec!["yaml", "json"]),
               ..ProtoDataOptions::default()
           })
        });
}

Finally, spawn a prototype with a system:

use bevy::prelude::*;
use bevy_proto_typetag::prelude::*;

fn spawn_enemy(mut commands: Commands, data: Res<ProtoData>, asset_server: Res<AssetServer>) {
    let proto = data.get_prototype("Simple Enemy").expect("Prototype doesn't exist!");

    // Spawns in our "Simple Enemy" Prototype
    proto.spawn(&mut commands, &data, &asset_server);
}

Modules

data

Provides resource and deserialization for prototype data.

prelude

Includes all public types and the macro to derive ProtoComponent.

Structs

ProtoPlugin

Inserts resources for loading prototypes.

Prototype

The default prototype object, providing the basics for the prototype system.

Traits

ProtoComponent

Specifies how a type inserts components into an entity.

Prototypical

Allows access to a prototype’s name and components so that it can be spawned in

Functions

deserialize_templates_list

A function used to deserialize a list of templates.

Derive Macros

ProtoComponent

Automatically implements ProtoComponent for the given struct or enum. This works on all structs and enums, including tuple and unit structs.