Crate bevy_enum_event 

Derive macros that generate Bevy event and message types from enum variants.

Each variant becomes a separate struct in a snake_case module.

Quick Start

use bevy::prelude::*;
use bevy_enum_event::EnumEvent;

#[derive(EnumEvent, Clone, Copy)]
enum GameState {
    MainMenu,
    Playing,
    Paused,
}

fn on_paused(paused: On<game_state::Paused>) {
    println!("Game paused!");
}

Macros

Bevy 0.17+ distinguishes between three event/message types:

• #[derive(EnumEvent)] - Observer-based global events (triggered via world.trigger())
• #[derive(EnumEntityEvent)] - Entity-targeted observer events with optional propagation
• #[derive(EnumMessage)] - Buffered messages (written via MessageWriter, read via MessageReader)

EnumEvent

For observer-based events that are triggered globally and handled by observers.

use bevy_enum_event::EnumEvent;

#[derive(EnumEvent, Clone)]
enum GameEvent {
    Victory(String),
    ScoreChanged { team: u32, score: i32 },
    GameOver,
}
// Generates: game_event::Victory, game_event::ScoreChanged, game_event::GameOver
// Each derives Event and is used with triggers and observers

EnumMessage

For buffered messages that are written/read between systems using MessageWriter/MessageReader. These require registration with app.add_message::<T>().

use bevy_enum_event::EnumMessage;

#[derive(EnumMessage, Clone)]
enum NetworkMessage {
    Connected(String),
    Disconnected { reason: String },
    DataReceived { data: Vec<u8> },
}
// Generates: network_message::Connected, network_message::Disconnected, network_message::DataReceived
// Each derives Message and is used with MessageWriter/MessageReader

Deref Feature (default)

Single-field variants auto-implement Deref/DerefMut. For multi-field variants, use #[enum_event(deref)]. Disable with default-features = false.

use bevy_enum_event::EnumEvent;
use std::ops::Deref;

#[derive(EnumEvent, Clone)]
enum NetworkEvent {
    MessageReceived(String),
    PlayerScored { #[enum_event(deref)] player: u32, points: u32 },
}

let msg = network_event::MessageReceived("Hello".to_string());
assert_eq!(msg.deref(), "Hello");

let scored = network_event::PlayerScored { player: 7, points: 120 };
assert_eq!(*scored.deref(), 7);

EnumEntityEvent

Entity-targeted events. Requires named fields with entity: Entity or #[enum_event(target)].

use bevy::prelude::*;
use bevy_enum_event::EnumEntityEvent;

#[derive(EnumEntityEvent, Clone, Copy)]
enum PlayerEvent {
    Damaged { entity: Entity, amount: f32 },
}

Custom Target

use bevy::prelude::*;
use bevy_enum_event::EnumEntityEvent;

#[derive(EnumEntityEvent, Clone, Copy)]
enum CombatEvent {
    Attack {
        #[enum_event(target)]
        attacker: Entity,
        defender: Entity,
    },
}

Propagation

use bevy::prelude::*;
use bevy_enum_event::EnumEntityEvent;

#[derive(EnumEntityEvent, Clone, Copy)]
#[enum_event(propagate)]
enum UiEvent {
    Click { entity: Entity },
}

#[derive(EnumEntityEvent, Clone, Copy)]
#[enum_event(auto_propagate, propagate)]
enum SystemEvent {
    Update { entity: Entity },
}

#[derive(EnumEntityEvent, Clone, Copy)]
#[enum_event(propagate = &'static ::bevy::prelude::ChildOf)]
enum CustomEvent {
    Action { entity: Entity },
}

Derive Macros

EnumEntityEvent

Generates Bevy EntityEvent types from enum variants.

EnumEvent

Generates Bevy Event types from enum variants for observer-based events.

EnumMessage

Generates Bevy Message types from enum variants for buffered message passing.