asminme
bbccd4a815
Build AsminVoicechat / prepare-release (push) Successful in 14s
Build AsminVoicechat / build-and-test (17) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (18) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (19) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (20) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (21) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (22) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (23) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (24) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (25) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (26) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (27-ea) (push) Canceled after 0s
Build AsminVoicechat / build-and-test (16) (push) Canceled after 38s
309 lines
15 KiB
Java
309 lines
15 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.annotation.Nullable
|
|
* org.bukkit.entity.Player
|
|
*/
|
|
package de.maxhenkel.voicechat.plugins;
|
|
|
|
import de.maxhenkel.voicechat.Voicechat;
|
|
import de.maxhenkel.voicechat.api.VoicechatConnection;
|
|
import de.maxhenkel.voicechat.api.VoicechatPlugin;
|
|
import de.maxhenkel.voicechat.api.VoicechatSocket;
|
|
import de.maxhenkel.voicechat.api.VolumeCategory;
|
|
import de.maxhenkel.voicechat.api.audiolistener.AudioListener;
|
|
import de.maxhenkel.voicechat.api.audiolistener.PlayerAudioListener;
|
|
import de.maxhenkel.voicechat.api.events.CreateGroupEvent;
|
|
import de.maxhenkel.voicechat.api.events.EntitySoundPacketEvent;
|
|
import de.maxhenkel.voicechat.api.events.Event;
|
|
import de.maxhenkel.voicechat.api.events.EventRegistration;
|
|
import de.maxhenkel.voicechat.api.events.JoinGroupEvent;
|
|
import de.maxhenkel.voicechat.api.events.LeaveGroupEvent;
|
|
import de.maxhenkel.voicechat.api.events.LocationalSoundPacketEvent;
|
|
import de.maxhenkel.voicechat.api.events.MicrophonePacketEvent;
|
|
import de.maxhenkel.voicechat.api.events.PlayerConnectedEvent;
|
|
import de.maxhenkel.voicechat.api.events.PlayerDisconnectedEvent;
|
|
import de.maxhenkel.voicechat.api.events.PlayerStateChangedEvent;
|
|
import de.maxhenkel.voicechat.api.events.RegisterVolumeCategoryEvent;
|
|
import de.maxhenkel.voicechat.api.events.RemoveGroupEvent;
|
|
import de.maxhenkel.voicechat.api.events.StaticSoundPacketEvent;
|
|
import de.maxhenkel.voicechat.api.events.UnregisterVolumeCategoryEvent;
|
|
import de.maxhenkel.voicechat.api.events.VoiceDistanceEvent;
|
|
import de.maxhenkel.voicechat.api.events.VoiceHostEvent;
|
|
import de.maxhenkel.voicechat.api.events.VoicechatServerStartedEvent;
|
|
import de.maxhenkel.voicechat.api.events.VoicechatServerStartingEvent;
|
|
import de.maxhenkel.voicechat.api.events.VoicechatServerStoppedEvent;
|
|
import de.maxhenkel.voicechat.plugins.EventBuilder;
|
|
import de.maxhenkel.voicechat.plugins.impl.GroupImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.VoicechatConnectionImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.VoicechatServerApiImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.VoicechatSocketImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.audiolistener.PlayerAudioListenerImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.CreateGroupEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.EntitySoundPacketEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.JoinGroupEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.LeaveGroupEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.LocationalSoundPacketEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.MicrophonePacketEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.PlayerConnectedEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.PlayerDisconnectedEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.PlayerStateChangedEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.RegisterVolumeCategoryEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.RemoveGroupEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.StaticSoundPacketEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.UnregisterVolumeCategoryEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.VoiceDistanceEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.VoiceHostEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.VoicechatServerStartedEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.VoicechatServerStartingEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.events.VoicechatServerStoppedEventImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.packets.EntitySoundPacketImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.packets.LocationalSoundPacketImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.packets.MicrophonePacketImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.packets.SoundPacketImpl;
|
|
import de.maxhenkel.voicechat.plugins.impl.packets.StaticSoundPacketImpl;
|
|
import de.maxhenkel.voicechat.voice.common.GroupSoundPacket;
|
|
import de.maxhenkel.voicechat.voice.common.LocationSoundPacket;
|
|
import de.maxhenkel.voicechat.voice.common.MicPacket;
|
|
import de.maxhenkel.voicechat.voice.common.PlayerSoundPacket;
|
|
import de.maxhenkel.voicechat.voice.common.PlayerState;
|
|
import de.maxhenkel.voicechat.voice.common.SoundPacket;
|
|
import de.maxhenkel.voicechat.voice.server.Group;
|
|
import de.maxhenkel.voicechat.voice.server.Server;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
import java.util.function.Consumer;
|
|
import javax.annotation.Nullable;
|
|
import org.bukkit.entity.Player;
|
|
|
|
public class PluginManager {
|
|
private List<VoicechatPlugin> plugins;
|
|
private Map<Class<? extends Event>, List<Consumer<? extends Event>>> events;
|
|
private final Map<UUID, List<PlayerAudioListener>> playerAudioListeners = new ConcurrentHashMap<UUID, List<PlayerAudioListener>>();
|
|
private static PluginManager instance;
|
|
|
|
public void init() {
|
|
Voicechat.LOGGER.info("Loading plugins", new Object[0]);
|
|
this.plugins = Voicechat.apiService.getPlugins();
|
|
Voicechat.LOGGER.info("Loaded {} plugin(s)", this.plugins.size());
|
|
Voicechat.LOGGER.info("Initializing plugins", new Object[0]);
|
|
for (VoicechatPlugin plugin : this.plugins) {
|
|
try {
|
|
plugin.initialize(VoicechatServerApiImpl.instance());
|
|
}
|
|
catch (Exception e) {
|
|
Voicechat.LOGGER.error("Failed to initialize plugin '{}'", plugin.getPluginId(), e);
|
|
}
|
|
}
|
|
Voicechat.LOGGER.info("Initialized {} plugin(s)", this.plugins.size());
|
|
this.gatherEvents();
|
|
}
|
|
|
|
private void gatherEvents() {
|
|
EventBuilder eventBuilder = EventBuilder.create();
|
|
EventRegistration registration = eventBuilder::addEvent;
|
|
for (VoicechatPlugin plugin : this.plugins) {
|
|
Voicechat.LOGGER.info("Registering events for '{}'", plugin.getPluginId());
|
|
try {
|
|
plugin.registerEvents(registration);
|
|
}
|
|
catch (Throwable t) {
|
|
Voicechat.LOGGER.error("Failed to register events for '{}'", plugin.getPluginId(), t);
|
|
}
|
|
}
|
|
this.events = eventBuilder.build();
|
|
}
|
|
|
|
public synchronized boolean registerAudioListener(AudioListener l) {
|
|
if (!(l instanceof PlayerAudioListener)) {
|
|
return false;
|
|
}
|
|
PlayerAudioListener listener = (PlayerAudioListener)l;
|
|
boolean exists = this.playerAudioListeners.values().stream().anyMatch(listeners -> listeners.stream().anyMatch(playerAudioListener -> playerAudioListener.getListenerId().equals(listener.getListenerId())));
|
|
if (exists) {
|
|
return false;
|
|
}
|
|
this.playerAudioListeners.computeIfAbsent(listener.getPlayerUuid(), k -> new CopyOnWriteArrayList()).add(listener);
|
|
return true;
|
|
}
|
|
|
|
public synchronized boolean unregisterAudioListener(UUID listenerId) {
|
|
boolean removed = this.playerAudioListeners.values().stream().anyMatch(listeners -> listeners.removeIf(listener -> listener.getListenerId().equals(listenerId)));
|
|
if (!removed) {
|
|
return false;
|
|
}
|
|
this.playerAudioListeners.values().removeIf(List::isEmpty);
|
|
return true;
|
|
}
|
|
|
|
public List<PlayerAudioListener> getPlayerAudioListeners(UUID playerUuid) {
|
|
return this.playerAudioListeners.getOrDefault(playerUuid, Collections.emptyList());
|
|
}
|
|
|
|
public void onListenerAudio(UUID playerUuid, SoundPacket<?> packet) {
|
|
if (playerUuid.equals(packet.getSender())) {
|
|
return;
|
|
}
|
|
List<PlayerAudioListener> listeners = this.getPlayerAudioListeners(playerUuid);
|
|
if (listeners.isEmpty()) {
|
|
return;
|
|
}
|
|
SoundPacketImpl soundPacket = packet instanceof GroupSoundPacket ? new StaticSoundPacketImpl((GroupSoundPacket)packet) : (packet instanceof PlayerSoundPacket ? new EntitySoundPacketImpl((PlayerSoundPacket)packet) : (packet instanceof LocationSoundPacket ? new LocationalSoundPacketImpl((LocationSoundPacket)packet) : new SoundPacketImpl(packet)));
|
|
for (PlayerAudioListener l : listeners) {
|
|
if (!(l instanceof PlayerAudioListenerImpl)) continue;
|
|
try {
|
|
((PlayerAudioListenerImpl)l).getListener().accept(soundPacket);
|
|
}
|
|
catch (Throwable t) {
|
|
Voicechat.LOGGER.error("Failed to process audio listener", t);
|
|
}
|
|
}
|
|
}
|
|
|
|
public <T extends Event> boolean dispatchEvent(Class<T> eventClass, T event) {
|
|
List<Consumer<? extends Event>> events = this.events.get(eventClass);
|
|
if (events == null) {
|
|
return false;
|
|
}
|
|
for (Consumer<? extends Event> evt : events) {
|
|
try {
|
|
Consumer<? extends Event> e = evt;
|
|
e.accept(event);
|
|
if (!event.isCancelled()) continue;
|
|
break;
|
|
}
|
|
catch (Throwable t) {
|
|
Voicechat.LOGGER.error("Failed to dispatch event '{}'", eventClass.getSimpleName(), t);
|
|
}
|
|
}
|
|
return event.isCancelled();
|
|
}
|
|
|
|
public VoicechatSocket getSocketImplementation() {
|
|
VoicechatServerStartingEventImpl event = new VoicechatServerStartingEventImpl();
|
|
this.dispatchEvent(VoicechatServerStartingEvent.class, event);
|
|
VoicechatSocket socket = event.getSocketImplementation();
|
|
if (socket == null) {
|
|
socket = new VoicechatSocketImpl();
|
|
Voicechat.LOGGER.debug("Using default voicechat socket implementation", new Object[0]);
|
|
} else {
|
|
Voicechat.LOGGER.info("Using custom voicechat socket implementation: {}", socket.getClass().getName());
|
|
}
|
|
return socket;
|
|
}
|
|
|
|
public String getVoiceHost(Player player, String voiceHost) {
|
|
VoiceHostEventImpl event = new VoiceHostEventImpl(player, voiceHost);
|
|
this.dispatchEvent(VoiceHostEvent.class, event);
|
|
return event.getVoiceHost();
|
|
}
|
|
|
|
public void onRegisterVolumeCategory(VolumeCategory category) {
|
|
this.dispatchEvent(RegisterVolumeCategoryEvent.class, new RegisterVolumeCategoryEventImpl(category));
|
|
}
|
|
|
|
public void onUnregisterVolumeCategory(VolumeCategory category) {
|
|
this.dispatchEvent(UnregisterVolumeCategoryEvent.class, new UnregisterVolumeCategoryEventImpl(category));
|
|
}
|
|
|
|
public void onServerStarted() {
|
|
this.dispatchEvent(VoicechatServerStartedEvent.class, new VoicechatServerStartedEventImpl());
|
|
}
|
|
|
|
public void onServerStopped() {
|
|
this.dispatchEvent(VoicechatServerStoppedEvent.class, new VoicechatServerStoppedEventImpl());
|
|
}
|
|
|
|
public void onPlayerConnected(@Nullable Player player) {
|
|
if (player == null) {
|
|
return;
|
|
}
|
|
this.dispatchEvent(PlayerConnectedEvent.class, new PlayerConnectedEventImpl(VoicechatConnectionImpl.fromPlayer(player)));
|
|
}
|
|
|
|
public void onPlayerDisconnected(UUID player) {
|
|
this.dispatchEvent(PlayerDisconnectedEvent.class, new PlayerDisconnectedEventImpl(player));
|
|
}
|
|
|
|
public void onPlayerStateChanged(PlayerState state) {
|
|
this.dispatchEvent(PlayerStateChangedEvent.class, new PlayerStateChangedEventImpl(state));
|
|
}
|
|
|
|
public boolean onJoinGroup(Player player, @Nullable Group group) {
|
|
if (group == null) {
|
|
return this.onLeaveGroup(player);
|
|
}
|
|
return this.dispatchEvent(JoinGroupEvent.class, new JoinGroupEventImpl(new GroupImpl(group), VoicechatConnectionImpl.fromPlayer(player)));
|
|
}
|
|
|
|
public boolean onCreateGroup(@Nullable Player player, @Nullable Group group) {
|
|
if (group == null) {
|
|
if (player == null) {
|
|
return false;
|
|
}
|
|
return this.onLeaveGroup(player);
|
|
}
|
|
return this.dispatchEvent(CreateGroupEvent.class, new CreateGroupEventImpl(new GroupImpl(group), VoicechatConnectionImpl.fromPlayer(player)));
|
|
}
|
|
|
|
public boolean onLeaveGroup(Player player) {
|
|
Group g;
|
|
UUID groupUUID;
|
|
Server server = Voicechat.SERVER.getServer();
|
|
if (server == null) {
|
|
return false;
|
|
}
|
|
GroupImpl group = null;
|
|
PlayerState state = server.getPlayerStateManager().getState(player.getUniqueId());
|
|
if (state != null && (groupUUID = state.getGroup()) != null && (g = server.getGroupManager().getGroup(groupUUID)) != null) {
|
|
group = new GroupImpl(g);
|
|
}
|
|
return this.dispatchEvent(LeaveGroupEvent.class, new LeaveGroupEventImpl(group, VoicechatConnectionImpl.fromPlayer(player)));
|
|
}
|
|
|
|
public boolean onRemoveGroup(Group group) {
|
|
return this.dispatchEvent(RemoveGroupEvent.class, new RemoveGroupEventImpl(new GroupImpl(group)));
|
|
}
|
|
|
|
public boolean onMicPacket(Player sender, PlayerState senderState, MicPacket packet) {
|
|
return this.dispatchEvent(MicrophonePacketEvent.class, new MicrophonePacketEventImpl(new MicrophonePacketImpl(packet, sender.getUniqueId()), new VoicechatConnectionImpl(sender, senderState)));
|
|
}
|
|
|
|
public float getDistance(Player sender, PlayerState senderState, MicPacket packet, float originalDistance) {
|
|
VoiceDistanceEventImpl event = new VoiceDistanceEventImpl(new MicrophonePacketImpl(packet, sender.getUniqueId()), new VoicechatConnectionImpl(sender, senderState), originalDistance);
|
|
this.dispatchEvent(VoiceDistanceEvent.class, event);
|
|
return event.getDistance();
|
|
}
|
|
|
|
public boolean onSoundPacket(@Nullable Player sender, @Nullable PlayerState senderState, Player receiver, PlayerState receiverState, SoundPacket<?> p, String source) {
|
|
VoicechatConnectionImpl senderConnection = null;
|
|
if (sender != null && senderState != null) {
|
|
senderConnection = new VoicechatConnectionImpl(sender, senderState);
|
|
}
|
|
VoicechatConnectionImpl receiverConnection = new VoicechatConnectionImpl(receiver, receiverState);
|
|
if (p instanceof LocationSoundPacket) {
|
|
return this.dispatchEvent(LocationalSoundPacketEvent.class, new LocationalSoundPacketEventImpl(new LocationalSoundPacketImpl((LocationSoundPacket)p), (VoicechatConnection)senderConnection, (VoicechatConnection)receiverConnection, source));
|
|
}
|
|
if (p instanceof PlayerSoundPacket) {
|
|
return this.dispatchEvent(EntitySoundPacketEvent.class, new EntitySoundPacketEventImpl(new EntitySoundPacketImpl((PlayerSoundPacket)p), (VoicechatConnection)senderConnection, (VoicechatConnection)receiverConnection, source));
|
|
}
|
|
if (p instanceof GroupSoundPacket) {
|
|
return this.dispatchEvent(StaticSoundPacketEvent.class, new StaticSoundPacketEventImpl(new StaticSoundPacketImpl((GroupSoundPacket)p), (VoicechatConnection)senderConnection, (VoicechatConnection)receiverConnection, source));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static synchronized PluginManager instance() {
|
|
if (instance == null) {
|
|
instance = new PluginManager();
|
|
}
|
|
return instance;
|
|
}
|
|
}
|
|
|