HostServer, Systems and Schedules

[g4borg]

I want to approach very basic usage first, before I get into the advanced features you already implement, and just tried to play around with directly sending a message.

I tried to implement message sending with the current official 0.19 release (I saw that the code will change for all that)

and I registered a system, that sends out messages typed into a box

(this code works fine and emits one event)

fn handle_send_chat_message(
    mut send_chat_messages: EventReader<SendChatMessage>, // local event emitted by the textbox
    mut client: ResMut<ClientConnectionManager>,
) {
    for event in send_chat_messages.read() {
        let message = &event.0;
        info!("Send message: {:?}", message);
        client
            .send_message_to_target::<MainChannel, ChatMessage>(&message, NetworkTarget::All)
            .unwrap_or_else(|e| {
                error!("Failed to send message: {:?}", e);
            });
    }
}

now i wanted the server to handle incoming messages, and saw similar examples also here

fn server_handle_chat_messages(
    mut input_reader: EventReader<MessageEvent<ChatMessage>>,
    entity_map: Res<ClientEntityMap>,
    mut commands: Commands,
) {
    for input in input_reader.read() {
        let client_id = input.from();
        let message = input.message.clone();
        info!("Received a message!");
    }
}

I used HostServer Setup.
However I seemed to get the "Received message!" twice. This lead me down debugging a lot, until I figured it out, it was once client and once server (of course, I had sent it with All).
I figured out, that I have to send the message with NetworkTarget::None, so only the server system picks it up.

But I would be still interested, what about systems that are not behind a compiler flag, would it suffice to only react to messages that are Client(0), if I want to have server only logic, or could I bind my system in some kind of ServerFixedUpdate Scheduler?

If I want to write systems, that work the same in a single player with networking enabled, I therefore have to ignore myself or all but myself in ::All messages?

If there are no such schedules yet, would that not also be some nice idea to make it easier to write server and client code?

Sorry for my stupid questions. I love your library.

[cBournhonesque]

I think it might be a bug?
When the client sends a message to the server with NetworkTarget::All, the server should redirect the message to all other clients (including the local client), so only the local client should receive the message via MessageEvent and not the server.
I think this might be fixed in the main branch. (which also makes the distinction between ClientMessage and ServerMessage more explicit so that you cannot confuse the two)

[g4borg]

Not sure it is a bug, as I realized it was my mistake that All really meant all participants, and sending it to Local(0) reached the server, while I used another Local identifier as HostClient identifier.

I stumbled on your comment in the code where you asked yourself if you should call it Participant instead, and it suddenly made sense.

Also, I used a bidirectional message here