Is there a way I can make a sort of One way vc bot thing - discord-jda

Question

Hello is there a way to make it so you can kinda have a 1 way vc where (how ive set it up so far) 2 accounts are somehow conected (ive made 2 be able to run from one jda project)
then have one of the bots in one vc and the other one in the other vc.
The first bot hears what is being said tn that vc then the second bot shound shares that in a second vc
so the people in the first vc cant hear the people in the second vc but the people in the second vc can hear the people in the first vc
Btw this is how i have connected the 2 bots in one jda project
Main.java:
public class Main {
public static void main(String[] args){
Bot bot = new Bot("token for bot 1");
Bot2 bot2 = new Bot2("token for bot 2");
bot.start();
bot2.start();
}
}
Bot.java:
import net.dv8tion.jda.api.JDABuilder;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import javax.security.auth.login.LoginException;
public class Bot {
ListenerAdapter[] listenerAdapters= new ListenerAdapter[]{new Help()};
String token;
public Bot(String token) {
this.token = token;
}
public void start() {
JDABuilder jdaBuilder = JDABuilder.createDefault(token);
jdaBuilder.addEventListeners(listenerAdapters);
jdaBuilder.setActivity(Activity.watching("1!help"));
try {
JDA jda = jdaBuilder.build();
jda.awaitReady();
} catch (LoginException | InterruptedException e){
e.printStackTrace();
}
}
}
Bot2.java:
import commands2.*;
import net.dv8tion.jda.api.entities.Activity;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.JDABuilder;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import javax.security.auth.login.LoginException;
public class Bot2 {
ListenerAdapter[] listenerAdapters = new ListenerAdapter[]{new Help2()};
String token;
public Bot2(String token) {
this.token = token;
}
public void start() {
JDABuilder jdaBuilder = JDABuilder.createDefault(token);
jdaBuilder.addEventListeners(listenerAdapters);
jdaBuilder.setActivity(Activity.watching("2!help"));
try {
JDA jda = jdaBuilder.build();
jda.awaitReady();
} catch (LoginException | InterruptedException e){
e.printStackTrace();
}
}
}
Whould this idea be posible?
(btw the way ive set this up works i juts run it in intellij and then both bots work)

Answer 1

I will only show you how to do the "streaming audio from one bot to another" - part.
The implementation is completely up to you (and whether you want to activate it via command or want the bots to join specific channels on startup etc.)
To be able to skip this part I will assume that both bots are already in their dedicated channels.
Before you can start you have to make some changes to your existing code, since you may need them later:
import net.dv8tion.jda.api.JDABuilder;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import javax.security.auth.login.LoginException;
public class Bot {
ListenerAdapter[] listenerAdapters= new ListenerAdapter[]{new Help()};
String token;
// this is new
JDA jda;
public Bot(String token) {
this.token = token;
}
public void start() {
JDABuilder jdaBuilder = JDABuilder.createDefault(token);
jdaBuilder.addEventListeners(listenerAdapters);
jdaBuilder.setActivity(Activity.watching("1!help"));
try {
// and this changed as well
this.jda = jdaBuilder.build();
jda.awaitReady();
} catch (LoginException | InterruptedException e){
e.printStackTrace();
}
}
}
I changed the code to make it possible to access the JDA instance via Bot using Bot.jda. These changes have to be made in Bot2 as well of course.
After making the changes you have to implement a way for the bots to join their dedicated voice channel, but this is up to you.
What you basically want is to plug the received audio of one bot into the sent audio of the other one.
Luckily, JDA offers an example on how to let a bot play back the receiving audio. In there, you can find the class EchoHandler.
public static class EchoHandler implements AudioSendHandler, AudioReceiveHandler
{
/*
All methods in this class are called by JDA threads when resources are available/ready for processing.
The receiver will be provided with the latest 20ms of PCM stereo audio
Note you can receive even while setting yourself to deafened!
The sender will provide 20ms of PCM stereo audio (pass-through) once requested by JDA
When audio is provided JDA will automatically set the bot to speaking!
*/
private final Queue<byte[]> queue = new ConcurrentLinkedQueue<>();
/* Receive Handling */
#Override // combine multiple user audio-streams into a single one
public boolean canReceiveCombined()
{
// limit queue to 10 entries, if that is exceeded we can not receive more until the send system catches up
return queue.size() < 10;
}
#Override
public void handleCombinedAudio(CombinedAudio combinedAudio)
{
// we only want to send data when a user actually sent something, otherwise we would just send silence
if (combinedAudio.getUsers().isEmpty())
return;
byte[] data = combinedAudio.getAudioData(1.0f); // volume at 100% = 1.0 (50% = 0.5 / 55% = 0.55)
queue.add(data);
}
/*
Disable per-user audio since we want to echo the entire channel and not specific users.
#Override // give audio separately for each user that is speaking
public boolean canReceiveUser()
{
// this is not useful if we want to echo the audio of the voice channel, thus disabled for this purpose
return false;
}
#Override
public void handleUserAudio(UserAudio userAudio) {} // per-user is not helpful in an echo system
*/
/* Send Handling */
#Override
public boolean canProvide()
{
// If we have something in our buffer we can provide it to the send system
return !queue.isEmpty();
}
#Override
public ByteBuffer provide20MsAudio()
{
// use what we have in our buffer to send audio as PCM
byte[] data = queue.poll();
return data == null ? null : ByteBuffer.wrap(data); // Wrap this in a java.nio.ByteBuffer
}
#Override
public boolean isOpus()
{
// since we send audio that is received from discord we don't have opus but PCM
return false;
}
}
This class basically does all the hard work for you. You can feed in an AudioReceiveHandler and plug it into an AudioSendHandler with the wanted result.
Only thing left now is to actually do it.
You want the audio from the first bot to be played by the second bot, like this:
(Note: You have to get guild and guild2 from the jda instances of Bot and Bot2.)
/*
example for getting the guilds:
Guild guild = bot.jda.getGuildById(GUILDID);
Guild guild2 = bot2.jda.getGuildById(GUILDID);
*/
AudioManager audioManager = guild.getAudioManager(); // of Bot
AudioManager audioManager2 = guild2.getAudioManager(); // of Bot2
EchoHandler handler = new EchoHandler();
audioManager.setReceivingHandler(handler);
audioManager2.setSendingHandler(handler);