Add splash potions entity to Spawner module

core/src/main/java/tc/oc/pgm/spawner/SpawnerDefinition.java

@@ -19,15 +19,16 @@ public class SpawnerDefinition implements FeatureDefinition {
   public final int numericID;
 
   public SpawnerDefinition(
+      int numericID,
       List<Spawnable> objects,
       Region spawnRegion,
       Region playerRegion,
       Filter playerFilter,
       Duration delay,
       Duration minDelay,
       Duration maxDelay,
-      int maxEntities,
-      int numericID) {
+      int maxEntities) {
+    this.numericID = numericID;
     this.spawnRegion = spawnRegion;
     this.playerRegion = playerRegion;
     this.maxEntities = maxEntities;
@@ -36,6 +37,5 @@ public SpawnerDefinition(
     this.delay = delay;
     this.objects = objects;
     this.playerFilter = playerFilter;
-    this.numericID = numericID;
   }
 }

core/src/main/java/tc/oc/pgm/spawner/SpawnerModule.java

@@ -5,8 +5,11 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Logger;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionType;
 import org.jdom2.Attribute;
 import org.jdom2.Document;
 import org.jdom2.Element;
@@ -24,6 +27,8 @@
 import tc.oc.pgm.regions.RegionModule;
 import tc.oc.pgm.regions.RegionParser;
 import tc.oc.pgm.spawner.objects.SpawnableItem;
+import tc.oc.pgm.spawner.objects.SpawnablePotion;
+import tc.oc.pgm.util.xml.InheritingElement;
 import tc.oc.pgm.util.xml.InvalidXMLException;
 import tc.oc.pgm.util.xml.XMLUtils;
 
@@ -49,58 +54,82 @@ public SpawnerModule parse(MapFactory factory, Logger logger, Document doc)
       RegionParser regionParser = factory.getRegions();
       KitParser kitParser = factory.getKits();
       FilterParser filterParser = factory.getFilters();
+      AtomicInteger numericId = new AtomicInteger(0);
 
-      int numericID = 0;
-      for (Element element :
+      for (Element spawnerEl :
           XMLUtils.flattenElements(doc.getRootElement(), "spawners", "spawner")) {
-        Region spawnRegion = regionParser.parseRequiredRegionProperty(element, "spawn-region");
-        Region playerRegion = regionParser.parseRequiredRegionProperty(element, "player-region");
-        Attribute delayAttr = element.getAttribute("delay");
-        Attribute minDelayAttr = element.getAttribute("min-delay");
-        Attribute maxDelayAttr = element.getAttribute("max-delay");
+        Region spawnRegion = regionParser.parseRequiredRegionProperty(spawnerEl, "spawn-region");
+        Region playerRegion = regionParser.parseRequiredRegionProperty(spawnerEl, "player-region");
+        Attribute delayAttr = spawnerEl.getAttribute("delay");
+        Attribute minDelayAttr = spawnerEl.getAttribute("min-delay");
+        Attribute maxDelayAttr = spawnerEl.getAttribute("max-delay");
 
         if ((minDelayAttr != null || maxDelayAttr != null) && delayAttr != null) {
           throw new InvalidXMLException(
-              "Attribute 'minDelay' and 'maxDelay' cannot be combined with 'delay'", element);
+              "Attribute 'minDelay' and 'maxDelay' cannot be combined with 'delay'", spawnerEl);
         }
 
         Duration delay = XMLUtils.parseDuration(delayAttr, Duration.ofSeconds(10));
         Duration minDelay = XMLUtils.parseDuration(minDelayAttr, delay);
         Duration maxDelay = XMLUtils.parseDuration(maxDelayAttr, delay);
 
         if (maxDelay.compareTo(minDelay) <= 0 && minDelayAttr != null && maxDelayAttr != null) {
-          throw new InvalidXMLException("Max-delay must be longer than min-delay", element);
+          throw new InvalidXMLException("Max-delay must be longer than min-delay", spawnerEl);
         }
 
         int maxEntities =
             XMLUtils.parseNumber(
-                element.getAttribute("max-entities"), Integer.class, Integer.MAX_VALUE);
+                spawnerEl.getAttribute("max-entities"), Integer.class, Integer.MAX_VALUE);
         Filter playerFilter =
-            filterParser.parseFilterProperty(element, "filter", StaticFilter.ALLOW);
+            filterParser.parseFilterProperty(spawnerEl, "filter", StaticFilter.ALLOW);
 
         List<Spawnable> objects = new ArrayList<>();
-        for (Element spawnable :
-            XMLUtils.getChildren(
-                element, "item")) { // TODO Add more types of spawnables once entity parser is built
-          ItemStack stack = kitParser.parseItem(spawnable, false);
-          SpawnableItem item = new SpawnableItem(stack, numericID);
+        for (Element itemEl : XMLUtils.getChildren(spawnerEl, "item")) {
+          ItemStack stack = kitParser.parseItem(itemEl, false);
+          SpawnableItem item = new SpawnableItem(stack, "spawner-" + numericId.get());
           objects.add(item);
         }
 
+        ImmutableList.Builder<PotionEffect> chBuilder = ImmutableList.builder();
+        for (Element potionEl : XMLUtils.getChildren(spawnerEl, "potion")) {
+          for (Element potionChild : potionEl.getChildren("effect")) {
+            chBuilder.add(XMLUtils.parsePotionEffect(new InheritingElement(potionChild)));
+          }
+          ImmutableList<PotionEffect> potionChildren = chBuilder.build();
+          if (potionChildren.isEmpty()) {
+            throw new InvalidXMLException("Expected child effects, but found none", spawnerEl);
+          }
+          int potionName = 0;
+          if (potionEl.getAttribute("damage") != null) {
+            potionName = XMLUtils.parseNumber(potionEl.getAttribute("damage"), Integer.class, 0);
+          } else {
+            for (PotionEffect potionEffect : potionChildren) {
+              // PotionType lists "true" potions, PotionEffectType lists all possible status effects
+              // (ie wither)
+              // Use the first listed PotionType for potion color
+              if (PotionType.getByEffect(potionEffect.getType()) != null) {
+                potionName = PotionType.getByEffect(potionEffect.getType()).getDamageValue();
+                break;
+              }
+            }
+          }
+          objects.add(
+              new SpawnablePotion(potionChildren, potionName, "spawner-" + numericId.get()));
+        }
+
         SpawnerDefinition spawnerDefinition =
             new SpawnerDefinition(
+                numericId.getAndIncrement(),
                 objects,
                 spawnRegion,
                 playerRegion,
                 playerFilter,
                 delay,
                 minDelay,
                 maxDelay,
-                maxEntities,
-                numericID);
-        factory.getFeatures().addFeature(element, spawnerDefinition);
+                maxEntities);
+        factory.getFeatures().addFeature(spawnerEl, spawnerDefinition);
         spawnerModule.spawnerDefinitions.add(spawnerDefinition);
-        numericID++;
       }
 
       return spawnerModule.spawnerDefinitions.isEmpty() ? null : spawnerModule;

core/src/main/java/tc/oc/pgm/spawner/objects/SpawnableItem.java

@@ -11,18 +11,18 @@
 
 public class SpawnableItem implements Spawnable {
 
-  private ItemStack stack;
-  private String METADATA_VALUE;
+  private final ItemStack stack;
+  private final String spawnerId;
 
-  public SpawnableItem(ItemStack stack, int spawnerID) {
+  public SpawnableItem(ItemStack stack, String spawnerId) {
     this.stack = stack;
-    this.METADATA_VALUE = Integer.toString(spawnerID);
+    this.spawnerId = spawnerId;
   }
 
   @Override
   public void spawn(Location location, Match match) {
     Item item = location.getWorld().dropItem(location, stack);
-    item.setMetadata(Spawner.METADATA_KEY, new FixedMetadataValue(PGM.get(), METADATA_VALUE));
+    item.setMetadata(Spawner.METADATA_KEY, new FixedMetadataValue(PGM.get(), spawnerId));
   }
 
   @Override

core/src/main/java/tc/oc/pgm/spawner/objects/SpawnablePotion.java

@@ -0,0 +1,43 @@
+package tc.oc.pgm.spawner.objects;
+
+import java.util.List;
+import org.bukkit.Location;
+import org.bukkit.entity.ThrownPotion;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.potion.Potion;
+import org.bukkit.potion.PotionEffect;
+import tc.oc.pgm.api.PGM;
+import tc.oc.pgm.api.match.Match;
+import tc.oc.pgm.spawner.Spawnable;
+import tc.oc.pgm.spawner.Spawner;
+
+public class SpawnablePotion implements Spawnable {
+  private final ItemStack potionItem;
+  private final String spawnerId;
+
+  public SpawnablePotion(List<PotionEffect> potion, int potionName, String spawnerId) {
+    this.spawnerId = spawnerId;
+    // Potion "name" determines potion color
+    ItemStack potionItem = new ItemStack(new Potion(potionName).splash().toItemStack(1));
+    PotionMeta potionMeta = (PotionMeta) potionItem.getItemMeta();
+    for (PotionEffect effect : potion) {
+      potionMeta.addCustomEffect(effect, false);
+    }
+    potionItem.setItemMeta(potionMeta);
+    this.potionItem = potionItem;
+  }
+
+  @Override
+  public void spawn(Location location, Match match) {
+    ThrownPotion thrownPotion = location.getWorld().spawn(location, ThrownPotion.class);
+    thrownPotion.setItem(potionItem.clone());
+    thrownPotion.setMetadata(Spawner.METADATA_KEY, new FixedMetadataValue(PGM.get(), spawnerId));
+  }
+
+  @Override
+  public int getSpawnCount() {
+    return potionItem.getAmount();
+  }
+}