Merge remote-tracking branch 'origin/master'

Author: Exceptionflug

protocolize-velocity/src/main/java/dev/simplix/protocolize/velocity/adventure/ProtocolizeAudience.java

@@ -1,11 +1,10 @@
 package dev.simplix.protocolize.velocity.adventure;
 
 import java.util.Collection;
-import java.util.stream.Collectors;
+import java.util.HashSet;
+import java.util.Objects;
 
 import com.velocitypowered.api.proxy.Player;
-import com.velocitypowered.api.proxy.ProxyServer;
-import com.velocitypowered.api.proxy.server.RegisteredServer;
 
 import dev.simplix.protocolize.api.Protocolize;
 import dev.simplix.protocolize.api.SoundCategory;
@@ -22,63 +21,36 @@
  * @author 4drian3d
  */
 public class ProtocolizeAudience {
-    private AudienceType TYPE;
-    private ProtocolizePlayer PLAYER;
-    private Collection<ProtocolizePlayer> PLAYERS;
+    private final Collection<ProtocolizePlayer> players = new HashSet<>();
     private static final ProtocolizePlayerProvider PLAYER_PROVIDER = Protocolize.playerProvider();
 
-    private enum AudienceType{
-        COLLECTION, SINGLE, NOTSUPPORTED
-    }
-
     /**
      * Obtain a {@link ProtocolizeAudience} from an {@link Audience}
      * @param audience The Audience
      */
     public ProtocolizeAudience(Audience audience){
-        if(audience instanceof RegisteredServer){
-            this.TYPE = AudienceType.COLLECTION;
-            this.PLAYERS = ((RegisteredServer)audience).getPlayersConnected().stream()
-                .map(player -> PLAYER_PROVIDER.player(player.getUniqueId()))
-                .collect(Collectors.toList());
-        } else if(audience instanceof ProxyServer){
-            this.TYPE = AudienceType.COLLECTION;
-            this.PLAYERS = ((ProxyServer)audience).getAllPlayers().stream()
-                .map(player -> PLAYER_PROVIDER.player(player.getUniqueId()))
-                .collect(Collectors.toList());
-        } else if(audience instanceof ForwardingAudience){
-            this.TYPE = AudienceType.COLLECTION;
-            for(Audience singleAudience : ((ForwardingAudience)audience).audiences()){
-                if(singleAudience instanceof Player){
-                    this.PLAYERS.add(getPlayer(singleAudience));
-                } else if(singleAudience instanceof RegisteredServer){
-                    ((RegisteredServer)singleAudience).getPlayersConnected().stream()
-                        .map(player -> PLAYER_PROVIDER.player(player.getUniqueId()))
-                        .forEach(this.PLAYERS::add);
-                } else if(singleAudience instanceof ForwardingAudience) {
-                    for(Audience miniAudience : ((ForwardingAudience)singleAudience).audiences()){
-                        if(miniAudience instanceof Player){
-                            this.PLAYERS.add(getPlayer(singleAudience));
-                        } else if(miniAudience instanceof RegisteredServer){
-                            ((RegisteredServer)miniAudience).getPlayersConnected().stream()
-                                .map(player -> PLAYER_PROVIDER.player(player.getUniqueId()))
-                                .forEach(this.PLAYERS::add);
-                        } else {
-                            /*
-                            It does not make sense to include the ProxyServer in a FowardingAudience
-                            */
-                        }
-                    }
-                }
+        Objects.requireNonNull(audience, "the audience cannot be null");
+        if(audience instanceof Player){
+            players.add(getPlayer(audience));
+        } else if(audience instanceof ForwardingAudience.Single){
+            Audience singleAudience = ((ForwardingAudience.Single)audience).audience();
+            if(singleAudience instanceof Player){
+                players.add(getPlayer(singleAudience));
             }
-        } else if(audience instanceof Player){
-            this.TYPE = AudienceType.SINGLE;
-            this.PLAYER = getPlayer(audience);
-        } else {
-            this.TYPE = AudienceType.NOTSUPPORTED;
+        } else if(audience instanceof ForwardingAudience){
+            checkAndAddPlayers((ForwardingAudience)audience);
         }
     }
 
+    /**
+     * Obtain a {@link ProtocolizeAudience} from an {@link Audience}
+     * @param audience The Audience
+     * @return The {@link ProtocolizeAudience}
+     */
+    public static ProtocolizeAudience audience(Audience audience){
+        return new ProtocolizeAudience(audience);
+    }
+
     /**
      * Plays a {@link Sound} to the specified {@link ProtocolizeAudience}
      * @param sound The sound to be played
@@ -87,14 +59,8 @@ public ProtocolizeAudience(Audience audience){
      * @param pitch Sound pitch
      */
     public void playSound(Sound sound, SoundCategory category, float volume, float pitch){
-        switch(TYPE){
-            case COLLECTION:
-                this.PLAYERS.forEach(pPlayer -> pPlayer.playSound(sound, category, volume, pitch));
-                break;
-            case SINGLE:
-                this.PLAYER.playSound(sound, category, volume, pitch);
-                break;
-            case NOTSUPPORTED: break;
+        for(ProtocolizePlayer player : players){
+            player.playSound(sound, category, volume, pitch);
         }
     }
 
@@ -103,29 +69,17 @@ public void playSound(Sound sound, SoundCategory category, float volume, float p
      * @param inventory The inventory
      */
     public void openInventory(Inventory inventory){
-        switch(TYPE){
-            case COLLECTION:
-                this.PLAYERS.forEach(pPlayer -> pPlayer.openInventory(inventory));
-                break;
-            case SINGLE:
-                this.PLAYER.openInventory(inventory);
-                break;
-            case NOTSUPPORTED: break;
+        for(ProtocolizePlayer player : players){
+            player.openInventory(inventory);
         }
     }
 
     /**
      * Closes the open inventories of the {@link ProtocolizeAudience}
      */
     public void closeInventory(){
-        switch(TYPE){
-            case COLLECTION:
-                this.PLAYERS.forEach(pPlayer -> pPlayer.closeInventory());
-                break;
-            case SINGLE:
-                this.PLAYER.closeInventory();
-                break;
-            case NOTSUPPORTED: break;
+        for(ProtocolizePlayer player : players){
+            player.closeInventory();
         }
     }
 
@@ -135,14 +89,8 @@ public void closeInventory(){
      * @param inventory The Inventory
      */
     public void registerInventory(int windowId, Inventory inventory){
-        switch(TYPE){
-            case COLLECTION:
-                this.PLAYERS.forEach(pPlayer -> pPlayer.registerInventory(windowId, inventory));
-                break;
-            case SINGLE:
-                this.PLAYER.registerInventory(windowId, inventory);
-                break;
-            case NOTSUPPORTED: break;
+        for(ProtocolizePlayer player : players){
+            player.registerInventory(windowId, inventory);
         }
     }
 
@@ -155,4 +103,19 @@ private static ProtocolizePlayer getPlayer(Audience audience){
         Player player = (Player) audience;
         return PLAYER_PROVIDER.player(player.getUniqueId());
     }
+
+    private void checkAndAddPlayers(ForwardingAudience fAudience){
+        for(Audience audience : fAudience.audiences()){
+            if(audience instanceof Player){
+                players.add(getPlayer(audience));
+            } else if(audience instanceof ForwardingAudience.Single){
+                Audience singleAudience = ((ForwardingAudience.Single)audience).audience();
+                if(singleAudience instanceof Player){
+                    players.add(getPlayer(singleAudience));
+                }
+            } else if(audience instanceof ForwardingAudience){
+                checkAndAddPlayers((ForwardingAudience)audience);
+            }
+        }
+    }
 }