EntityEvent cannot be derived for enums

[perry-blueberry]

Bevy version and features

0.17.2

What you did

Porting to 0.17, where I previously had an Event used as an entity event for an enum.

#[derive(EntityEvent)]
enum A {}

What went wrong

EntityEvent can only be derived for structs.

[alice-i-cecile]

Note that each variant will need to store an Entity. For now, I would use a manual implementation.

[perry-blueberry]

Note that each variant will need to store an Entity.

Why? The enum I have looks like this

#[derive(Event, PartialEq)]
pub enum RecalculateState {
    NewSegment,
    Forced(Entity, usize),
}

Basically tells it to calculate the state for the first time or that it needs to be force recalculated taking into account the entity inside Forced. Is this not a correct usage of entity events? It seemed reasonable when I wrote it...

[perry-blueberry]

I'm using it like

commands
                .entity(entity)
                .trigger(RecalculateState::NewSegment);

I cannot find an example in the migration guide that translates this to something else.

[perry-blueberry]

Not ideal...

Before:

#[derive(Event, PartialEq)]
pub enum RecalculateState {
    NewSegment,
    Forced(Entity, usize),
}

After:

#[derive(Event, PartialEq)]
pub enum RecalculateState {
    NewSegment {
        target: Entity,
    },
    Forced {
        target: Entity,
        other: Entity,
        something: usize,
    },
}

impl RecalculateState {
    fn is_new_segment(&self) -> bool {
        match self {
            RecalculateState::NewSegment { .. } => true,
            RecalculateState::Forced { .. } => false,
        }
    }
}

impl EntityEvent for RecalculateState {
    fn event_target(&self) -> Entity {
        match self {
            RecalculateState::NewSegment { target } => *target,
            RecalculateState::Forced { target, .. } => *target,
        }
    }

    fn event_target_mut(&mut self) -> &mut Entity {
        match self {
            RecalculateState::NewSegment { target } => target,
            RecalculateState::Forced { target, .. } => target,
        }
    }
}

Is it too late to get the old behavior back 😛 when you don't have to name something as entity for derives (for structs only currently)? This is quite a regression in user experience IMO and the first of it's kind I've faced in Bevy.

I've been looking into Zig recently and one thing that bothered me about it was its ad-hoc interfaces where you'd had to put the right thing inside your struct... which is basically what the new API is asking for here with entity and if the derive gets implemented for enums as well it will be even more confusing. I just don't like it...

I do like how the new naming disambiguates things though! So half of this new API I do like.

[alice-i-cecile]

This was @cart's decision. I agree that this is not ideal for enum entity events: I'd probably do:

struct MyEvent {
  entity: Entity,
  payload: MyEnum,
}

[perry-blueberry]

This was @cart's decision. I agree that this is not ideal for enum entity events: I'd probably do:

struct MyEvent {
entity: Entity,
payload: MyEnum,
}

This is a bit better, yeah. Thanks for the suggestion! Ideally though I think this would be even better (but more prone to ambiguities as well):

struct MyEvent(Entity, MyEnum)

Not the end of the world though.

I also realized that using the enum made it so that the event didn't fire at all. Seems Bevy might eat that one up for some reason. It does work with the enum inside the struct though. I tried to create a minimal reproducible project but then couldn't see a difference between struct and enum triggering an event. I also don't understand how to observe with the new APIs. commands.entity(entity).observe(my_system); doesn't seem to work anymore? Or it's only in certain situations it doesn't work anymore. For the minimally reproducible project I had to do App::new().add_observer(my_system) for observers to trigger. This has all gotten very confusing to use. I don't know if I'm doing things wrong or not but I didn't have this confusion with the previous API.