How can we have a console in a separate thread?

[visualcode-t]

I am looking to have a console which waits for input and passes that information for my main Bevy app to handle. But, I am completely unsure how to go about this. What would be the best way to make this work?

[DJMcNab]

One simple way would probably be to read from stdin, which normally gets flushed every time you press enter. E.g. you can use https://doc.rust-lang.org/std/io/trait.BufRead.html#method.read_line on std::io::stdin().
For that you'd need to create a seperate thread (before calling App::run), and then use a channel to send the data into bevy, via putting the channel in a resource. See https://stackoverflow.com/questions/30012995/how-can-i-read-non-blocking-from-stdin

Edit: Added code from #1150 (reply in thread) to accepted answer

Code hidden to save space

use std::io::stdin;

use bevy::prelude::*;
use crossbeam_channel::{bounded, Receiver};

fn main() {
    let (tx, rx) = bounded::<String>(1);
    std::thread::spawn(move || loop {
        let mut buf = String::new();
        stdin().read_line(&mut buf).unwrap();
        tx.send(buf).unwrap();
    });
    App::build()
        .add_event::<StdinLine>()
        .add_plugins(DefaultPlugins)
        .add_thread_local_resource(StdinReceiver(rx))
        .add_system_to_stage(stage::PRE_EVENT, read_stdin_system.system())
        .add_system(log_stdin_system.system())
        .run();
}

struct StdinReceiver(Receiver<String>);
struct StdinLine(String);
fn read_stdin_system(_: &mut World, resources: &mut Resources) {
    let rx = resources.get_thread_local_mut::<StdinReceiver>().unwrap();
    let mut events = resources.get_mut::<Events<StdinLine>>().unwrap();
    if let Ok(line) = rx.0.try_recv() {
        events.send(StdinLine(line));
    }
}

fn log_stdin_system(mut reader: Local<EventReader<StdinLine>>, events: Res<Events<StdinLine>>) {
    for line in reader.iter(&events) {
        println!("Stdin gave {:?}", line.0);
    }
}

[visualcode-t]

use std::io;
use std::sync::mpsc;
use std::sync::mpsc::{Receiver,TryRecvError};
use std::{thread, time};
use bevy::prelude::*;

fn main() {
    let (tx,rx) = mpsc::channel::<String>();
    thread::spawn(move || loop {
        let stdin_channel = spawn_stdin_channel();
        match stdin_channel.try_recv() {
            Ok(key) => tx.send(key).unwrap(),
            Err(TryRecvError::Empty) => (), //println!("Channel empty"),
            Err(TryRecvError::Disconnected) => panic!("Channel disconnected"),
        }
        thread::sleep(time::Duration::from_millis(100));
    });
    App::build()
        .add_plugins(DefaultPlugins)
        .run();
}

fn spawn_stdin_channel() -> Receiver<String> {
    let (tx, rx) = mpsc::channel::<String>();
        let mut buffer = String::new();
        io::stdin().read_line(&mut buffer).unwrap();
        tx.send(buffer).unwrap();
    rx
}

I've attempted to put this together and I've come up with the preceding example. But, when I attempt to add a resource it states that it cannot be shared safely between threads. The only success I've had is adding a resource of rx.recv() but that only passes the first result.

[DJMcNab]

That's nearly it. The thing you are missing is that you need to use app.add_thread_local_resource(my_reciever), then to access it you need to create a thread local system to access it. That is, the full example should look something like:

Code hidden for future readers

use std::io::stdin;

use bevy::prelude::*;
use crossbeam_channel::{bounded, Receiver};

fn main() {
    let (tx, rx) = bounded::<String>(1);
    std::thread::spawn(move || loop {
        let mut buf = String::new();
        stdin().read_line(&mut buf).unwrap();
        tx.send(buf).unwrap();
    });
    App::build()
        .add_event::<StdinLine>()
        .add_plugins(DefaultPlugins)
        .add_thread_local_resource(StdinReceiver(rx))
        .add_system_to_stage(stage::PRE_EVENT, read_stdin_system.system())
        .add_system(log_stdin_system.system())
        .run();
}

struct StdinReceiver(Receiver<String>);
struct StdinLine(String);
fn read_stdin_system(_: &mut World, resources: &mut Resources) {
    let rx = resources.get_thread_local_mut::<StdinReceiver>().unwrap();
    let mut events = resources.get_mut::<Events<StdinLine>>().unwrap();
    if let Ok(line) = rx.0.try_recv() {
        events.send(StdinLine(line));
    }
}

fn log_stdin_system(mut reader: Local<EventReader<StdinLine>>, events: Res<Events<StdinLine>>) {
    for line in reader.iter(&events) {
        println!("Stdin gave {:?}", line.0);
    }
}

[dominikj111]

I have not been able to use the add_thread_local_resource neither to find it in the repo. So I have to suppose it was removed, but I didn't find any comment about it anywhere.

Anyway, thanks to the previous example, I have been able to get my stuff working by:

...

#[derive(Resource)]
struct MyReceiverTag((Mutex<Receiver<String>>);

pub fn main() {
    let rx = start_data_handler();
    App::new()
        .insert_resource(MyReceiverTag(Mutex::new(rx)))
        .add_plugins(DefaultPlugins)
        .add_systems(FixedFirst, process_received_data)
        .run();
}

fn start_data_handler() -> Receiver<String> {
    let (tx, rx): (Sender<String>, Receiver<String>) = mpsc::channel();

    thread::spawn(move || {
        ...
        loop {
            ...
            // stdin().read_line; unix_stream.read_to_string; ...
            ...
            tx.send(message).unwrap();
        }
    });

    rx
}

fn process_received_data(rx: Res<MyReceiverTag>) {
    if let Ok(data) = rx.0.lock().unwrap().try_recv() {
        println!("received: {}", data);
    }
}

[visualcode-t]

That is awesome, thank you! I got my example working by changing it to a thread_local_resource, as you suggested. I wasn't aware of that feature I definitely need to play some more with threads in general. Also, I like your use of events, another feature I haven't played with, I'll work on that now!

One question about Bevy: Why do we have to have a reference to World in order to reference Resources?

Completed example of the original code-snippet.

use std::io;
use std::sync::mpsc;
use std::sync::mpsc::{Receiver,TryRecvError};
use std::{thread, time};
use bevy::prelude::*;

fn main() {
    let (tx,rx) = mpsc::channel::<String>();
    thread::spawn(move || loop {
        let stdin_channel = spawn_stdin_channel();
        match stdin_channel.try_recv() {
            Ok(key) => tx.send(key).unwrap(),
            Err(TryRecvError::Empty) => (),
            Err(TryRecvError::Disconnected) => panic!("Channel disconnected"),
        }
        thread::sleep(time::Duration::from_millis(100));
    });
    App::build()
        .add_plugins(DefaultPlugins)
        .add_thread_local_resource(rx)
        .add_system(cons_comm.system())
        .run();
}

fn cons_comm(_: &mut World, mut resources: &mut Resources) {
    let rx = resources.get_thread_local_mut::<Receiver<String>>().unwrap();
    if let Ok(text) = rx.try_recv() {
        println!("{:?}",text);
    }
}

fn spawn_stdin_channel() -> Receiver<String> {
    let (tx, rx) = mpsc::channel::<String>();
        let mut buffer = String::new();
        io::stdin().read_line(&mut buffer).unwrap();
        tx.send(buffer).unwrap();
    rx
}

[DJMcNab]

You can reply to a thread in a discussion using the reply box within that thread, rather than making a new top-level comment.

---

We need it because it uses this implementation, which is the only way to get access to Resources

bevy/crates/bevy_ecs/src/system/into_thread_local.rs

Lines 59 to 72 in 4825051

	impl<F> IntoSystem<(&mut World, &mut Resources), ThreadLocalSystemFn> for F
	where
	F: FnMut(&mut World, &mut Resources) + Send + Sync + 'static,
	{
	fn system(mut self) -> ThreadLocalSystemFn {
	ThreadLocalSystemFn {
	func: Box::new(move |world, resources| (self)(world, resources)),
	name: core::any::type_name::<F>().into(),
	id: SystemId::new(),
	resource_access: TypeAccess::default(),
	archetype_component_access: TypeAccess::default(),
	}
	}
	}

I also don't know why you are using that spawn_stdin_channel function - that is running on the same background thread - so the function is equivalent to just returning a Box<String>.
I.e. it can just be

fn spawn_stdin_channel() -> String {
    let mut buf = String::new();
    io::stdin()::read_line(&mut buf).unwrap();
    buf
}

I'd personally encourage you to use the example I sent verbatim - I think I'm going to make it a crate/put it in a repository so that the licensing is clearer, but you're free to use it.

[visualcode-t]

Yeah, that was from the stack-overflow example. I started there, got it working, then worked back to your example. I like to work through things in steps to ensure I understand everything rather than copy-pasting and accepting things as-is. I quickly realized that their use of spawn_stdin_channel was unnecessary. Now, I am using something almost identical to yours. Only, I am not using crossbeam.

[DJMcNab]

Ah that makes sense. Yeah, using crossbeam is probably not necessary.