Display entity projectiles

core/src/main/java/tc/oc/pgm/projectile/ProjectileDefinition.java

@@ -15,13 +15,16 @@ public class ProjectileDefinition extends SelfIdentifyingFeatureDefinition {
   protected @Nullable Float power;
   protected double velocity;
   protected ClickAction clickAction;
-  protected Class<? extends Entity> projectile;
+  protected ProjectileEntity projectile;
   protected List<PotionEffect> potion;
   protected Filter destroyFilter;
   protected Duration coolDown;
   protected boolean throwable;
   protected boolean precise;
   protected BlockMaterialData blockMaterial;
+  protected float scale;
+  protected boolean solidBlockCollision;
+  protected Duration maxTravelTime;
 
   public ProjectileDefinition(
       @Nullable String id,
@@ -30,13 +33,16 @@ public ProjectileDefinition(
       @Nullable Float power,
       double velocity,
       ClickAction clickAction,
-      Class<? extends Entity> entity,
+      ProjectileEntity entity,
       List<PotionEffect> potion,
       Filter destroyFilter,
       Duration coolDown,
       boolean throwable,
       boolean precise,
-      BlockMaterialData blockMaterial) {
+      BlockMaterialData blockMaterial,
+      float scale,
+      boolean solidBlockCollision,
+      Duration maxTravelTime) {
     super(id);
     this.name = name;
     this.damage = damage;
@@ -50,6 +56,31 @@ public ProjectileDefinition(
     this.throwable = throwable;
     this.precise = precise;
     this.blockMaterial = blockMaterial;
+    this.scale = scale;
+    this.solidBlockCollision = solidBlockCollision;
+    this.maxTravelTime = maxTravelTime;
+  }
+
+  public static sealed class ProjectileEntity {
+    public static final class RealEntity extends ProjectileEntity {
+      public final Class<? extends Entity> entityType;
+
+      public RealEntity(Class<? extends Entity> entityType) {
+        this.entityType = entityType;
+      }
+    }
+
+    public static final class AbstractEntity extends ProjectileEntity {
+      public final AbstractEntityType entityType;
+
+      public AbstractEntity(AbstractEntityType entityType) {
+        this.entityType = entityType;
+      }
+    }
+
+    enum AbstractEntityType {
+      BLOCK
+    }
   }
 
   public @Nullable String getName() {

core/src/main/java/tc/oc/pgm/projectile/ProjectileMatchModule.java

@@ -1,10 +1,17 @@
 package tc.oc.pgm.projectile;
 
 import static tc.oc.pgm.util.Assert.assertTrue;
+import static tc.oc.pgm.util.nms.Packets.ENTITIES;
 
 import com.google.common.collect.ImmutableSet;
+
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.UUID;
+import java.util.concurrent.*;
+import java.util.function.BooleanSupplier;
+
+import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Entity;
@@ -37,16 +44,22 @@
 import tc.oc.pgm.api.match.Match;
 import tc.oc.pgm.api.match.MatchModule;
 import tc.oc.pgm.api.match.MatchScope;
+import tc.oc.pgm.api.party.Party;
 import tc.oc.pgm.api.player.MatchPlayer;
 import tc.oc.pgm.api.player.ParticipantState;
 import tc.oc.pgm.events.ListenerScope;
 import tc.oc.pgm.events.PlayerParticipationStopEvent;
 import tc.oc.pgm.filters.query.BlockQuery;
 import tc.oc.pgm.filters.query.PlayerBlockQuery;
 import tc.oc.pgm.kits.tag.ItemTags;
+import tc.oc.pgm.projectile.path.LinearProjectilePath;
+import tc.oc.pgm.projectile.path.ProjectilePath;
 import tc.oc.pgm.util.bukkit.MetadataUtils;
 import tc.oc.pgm.util.inventory.InventoryUtils;
 import tc.oc.pgm.util.nms.NMSHacks;
+import tc.oc.pgm.util.nms.packets.BlockEntity;
+import tc.oc.pgm.util.nms.packets.FakeEntity;
+import tc.oc.pgm.util.nms.packets.Packet;
 
 @ListenerScope(MatchScope.RUNNING)
 public class ProjectileMatchModule implements MatchModule, Listener {
@@ -88,32 +101,96 @@ && isValidProjectileAction(event.getAction(), projectileDefinition.clickAction))
 
       if (this.isCooldownActive(player, projectileDefinition)) return;
 
-      boolean realProjectile = Projectile.class.isAssignableFrom(projectileDefinition.projectile);
+      boolean realProjectile = false;
+      if (projectileDefinition.projectile instanceof ProjectileDefinition.ProjectileEntity.RealEntity) {
+        realProjectile = Projectile.class.isAssignableFrom(
+            ((ProjectileDefinition.ProjectileEntity.RealEntity) projectileDefinition.projectile).entityType
+        );
+      }
       Vector velocity =
           player.getEyeLocation().getDirection().multiply(projectileDefinition.velocity);
-      Entity projectile;
+      Entity projectile = null;
+      BlockEntity blockEntity = null;
       try {
         assertTrue(launchingDefinition.get() == null, "nested projectile launch");
         launchingDefinition.set(projectileDefinition);
         if (realProjectile) {
           projectile = player.launchProjectile(
-              projectileDefinition.projectile.asSubclass(Projectile.class), velocity);
+            (((ProjectileDefinition.ProjectileEntity.RealEntity) projectileDefinition.projectile).entityType)
+              .asSubclass(Projectile.class),
+              velocity
+          );
           if (projectile instanceof Fireball fireball && projectileDefinition.precise) {
             NMSHacks.NMS_HACKS.setFireballDirection(fireball, velocity);
           }
         } else {
-          if (FallingBlock.class.isAssignableFrom(projectileDefinition.projectile)) {
+          if ((projectileDefinition.projectile instanceof ProjectileDefinition.ProjectileEntity.RealEntity) &&
+                  FallingBlock.class.isAssignableFrom((((ProjectileDefinition.ProjectileEntity.RealEntity) projectileDefinition.projectile).entityType))) {
             projectile =
                 projectileDefinition.blockMaterial.spawnFallingBlock(player.getEyeLocation());
           } else {
-            projectile =
-                player.getWorld().spawn(player.getEyeLocation(), projectileDefinition.projectile);
+            Location loc = player.getEyeLocation();
+            if ((projectileDefinition.projectile instanceof ProjectileDefinition.ProjectileEntity.AbstractEntity) &&
+                    ((ProjectileDefinition.ProjectileEntity.AbstractEntity) projectileDefinition.projectile).entityType == ProjectileDefinition.ProjectileEntity.AbstractEntityType.BLOCK) {
+              loc.setPitch(0);
+              loc.setYaw(0);
+              blockEntity = ENTITIES.spawnBlockEntity(loc, projectileDefinition.blockMaterial);
+              projectile = blockEntity.entity();
+            } else if (projectileDefinition.projectile instanceof ProjectileDefinition.ProjectileEntity.RealEntity) {
+              projectile =
+                      player.getWorld().spawn(loc, ((ProjectileDefinition.ProjectileEntity.RealEntity) projectileDefinition.projectile).entityType);
+            }
           }
           projectile.setVelocity(velocity);
         }
         if (projectileDefinition.power != null && projectile instanceof Explosive) {
           ((Explosive) projectile).setYield(projectileDefinition.power);
         }
+        if (blockEntity != null && blockEntity.isDisplayEntity()) {
+          Location loc = player.getEyeLocation();
+
+          blockEntity.align(loc.getPitch(), loc.getYaw(), projectileDefinition.scale);
+
+          blockEntity.setBlock(projectileDefinition.blockMaterial.getItemType());
+
+          final Vector normalizedDirection = player.getLocation().getDirection().normalize();
+          final LinearProjectilePath linearProjectilePath = new LinearProjectilePath(
+            normalizedDirection, projectileDefinition.velocity
+          );
+          final Location initialLocation = projectile.getLocation();
+
+          BlockEntity finalBlockEntity = blockEntity;
+          Entity finalProjectile = projectile;
+          runFixedTimesAtPeriod(
+              match.getExecutor(MatchScope.RUNNING),
+              new BooleanSupplier() {
+                private int progress = 0;
+
+
+                @Override
+                public boolean getAsBoolean() {
+                  finalBlockEntity.setTeleportationDuration(1);
+
+                  Location currentLocation = finalProjectile.getLocation();
+                  Location incrementingLocation = currentLocation.clone();
+                  Location newLocation = calculateTo(initialLocation, linearProjectilePath, ++progress);
+
+                  finalProjectile.teleport(newLocation);
+                  if (projectileDefinition.damage != null || projectileDefinition.solidBlockCollision) {
+                    while (currentLocation.distanceSquared(incrementingLocation) < currentLocation.distanceSquared(newLocation)) {
+                      if (blockDisplayCollision(projectileDefinition, player, incrementingLocation)) {
+                        return true;
+                      }
+                      incrementingLocation.add(normalizedDirection.clone().multiply(projectileDefinition.scale));
+                    }
+                    return blockDisplayCollision(projectileDefinition, player, incrementingLocation);
+                  }
+                  return false;
+                }
+              },
+              1L, projectileDefinition.maxTravelTime.toMillis(), projectile::remove
+          );
+        }
         projectile.setMetadata(
             "projectileDefinition", new FixedMetadataValue(PGM.get(), projectileDefinition));
       } finally {
@@ -142,6 +219,72 @@ && isValidProjectileAction(event.getAction(), projectileDefinition.clickAction))
     }
   }
 
+  private boolean blockDisplayCollision(ProjectileDefinition projectileDefinition, Player player, Location location) {
+    if (projectileDefinition.damage != null) {
+      Collection<Entity> nearbyEntities = location.getNearbyEntities(0.5 * projectileDefinition.scale, 0.5 * projectileDefinition.scale, 0.5 * projectileDefinition.scale);
+      if (!nearbyEntities.isEmpty()) {
+        Party playerParty = PGM.get().getMatchManager().getPlayer(player).getParty();
+        for (Entity entity : nearbyEntities) {
+          if (entity instanceof Player) {
+            if (playerParty != PGM.get().getMatchManager().getPlayer(((Player) entity)).getParty()) {
+              ((Player) entity).damage(projectileDefinition.damage, player);
+              return true;
+            }
+          }
+        }
+      }
+    }
+    if (projectileDefinition.solidBlockCollision) {
+      double posScale = 0.5 * projectileDefinition.scale;
+      double negScale = -0.5 * projectileDefinition.scale;
+
+      Block b1 = location.clone().add(negScale, negScale, negScale).getBlock();
+      Block b2 = location.clone().add(posScale, negScale, negScale).getBlock();
+      Block b3 = location.clone().add(negScale, posScale, negScale).getBlock();
+      Block b4 = location.clone().add(posScale, posScale, negScale).getBlock();
+      Block b5 = location.clone().add(negScale, negScale, posScale).getBlock();
+      Block b6 = location.clone().add(posScale, negScale, posScale).getBlock();
+      Block b7 = location.clone().add(negScale, posScale, posScale).getBlock();
+      Block b8 = location.clone().add(posScale, posScale, posScale).getBlock();
+
+      return b1.getType().isSolid() || b2.getType().isSolid() || b3.getType().isSolid() || b4.getType().isSolid() || b5.getType().isSolid() || b6.getType().isSolid() || b7.getType().isSolid() || b8.getType().isSolid();
+    }
+    return false;
+  }
+
+  // For entities which need their velocity simulated
+  private Location calculateTo(
+          final Location entityLocation,
+          final ProjectilePath path,
+          final int progress) {
+    return entityLocation.clone().add(path.getPositionAtProgress(progress));
+  }
+
+  private static void runFixedTimesAtPeriod(
+        final ScheduledExecutorService scheduledExecutorService, final BooleanSupplier runnable,
+        final long periodTicks, final long upperBoundMillis,
+        final Runnable finishHandler
+  ) {
+    final ScheduledFuture<?>[] ref = new ScheduledFuture[2];
+    final ScheduledFuture<?> mainTask = scheduledExecutorService.scheduleAtFixedRate(
+        () -> {
+          final boolean shouldCancel = runnable.getAsBoolean();
+          if (shouldCancel) {
+            ref[0].cancel(true);
+            ref[1].cancel(true);
+            finishHandler.run();
+          }
+        }, 0L, periodTicks * 50L, TimeUnit.MILLISECONDS
+    );
+    final ScheduledFuture<?> cleanupTask = scheduledExecutorService.schedule(() -> {
+      if (ref[0].isCancelled()) return;
+      ref[0].cancel(true);
+      finishHandler.run();
+    }, upperBoundMillis, TimeUnit.MILLISECONDS);
+    ref[0] = mainTask;
+    ref[1] = cleanupTask;
+  }
+
   @EventHandler
   public void onProjectileHurtEvent(EntityDamageByEntityEvent event) {
     if (!(event.getEntity() instanceof LivingEntity)) return;

core/src/main/java/tc/oc/pgm/projectile/ProjectileModule.java

@@ -1,11 +1,13 @@
 package tc.oc.pgm.projectile;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import java.time.Duration;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.logging.Logger;
 import org.bukkit.entity.Arrow;
@@ -23,6 +25,7 @@
 import tc.oc.pgm.filters.parse.FilterParser;
 import tc.oc.pgm.kits.KitParser;
 import tc.oc.pgm.util.material.BlockMaterialData;
+import tc.oc.pgm.util.nms.NMSHacks;
 import tc.oc.pgm.util.xml.InvalidXMLException;
 import tc.oc.pgm.util.xml.Node;
 import tc.oc.pgm.util.xml.XMLUtils;
@@ -62,9 +65,9 @@ public ProjectileModule parse(MapFactory factory, Logger logger, Document doc)
             Node.fromChildOrAttr(projectileElement, "velocity"), Double.class, 1.0);
         ClickAction clickAction = XMLUtils.parseEnum(
             Node.fromAttr(projectileElement, "click"), ClickAction.class, ClickAction.BOTH);
-        Class<? extends Entity> entity =
-            XMLUtils.parseEntityTypeAttribute(projectileElement, "projectile", Arrow.class);
-        BlockMaterialData blockMaterial = entity.isAssignableFrom(FallingBlock.class)
+        ProjectileDefinition.ProjectileEntity entity =
+                parseProjectileEntity(projectileElement, "projectile", Arrow.class);
+        BlockMaterialData blockMaterial = acceptsBlockMaterial(entity)
             ? XMLUtils.parseBlockMaterialData(Node.fromAttr(projectileElement, "material"))
             : null;
         Float power = XMLUtils.parseNumber(
@@ -76,6 +79,9 @@ public ProjectileModule parse(MapFactory factory, Logger logger, Document doc)
         boolean throwable =
             XMLUtils.parseBoolean(projectileElement.getAttribute("throwable"), true);
         boolean precise = XMLUtils.parseBoolean(projectileElement.getAttribute("precise"), true);
+        float scale = XMLUtils.parseNumber(Node.fromChildOrAttr(projectileElement, "scale"), Float.class, 1.0f);
+        boolean solidBlockCollision = XMLUtils.parseBoolean(projectileElement.getAttribute("solid-block-collision"), true);
+        Duration maxTravelTime = XMLUtils.parseDuration(projectileElement.getAttribute("max-travel-time"), Duration.ofSeconds(1));
 
         ProjectileDefinition projectileDefinition = new ProjectileDefinition(
             id,
@@ -90,13 +96,53 @@ public ProjectileModule parse(MapFactory factory, Logger logger, Document doc)
             coolDown,
             throwable,
             precise,
-            blockMaterial);
+            blockMaterial,
+            scale,
+            solidBlockCollision,
+            maxTravelTime);
 
         factory.getFeatures().addFeature(projectileElement, projectileDefinition);
         projectiles.add(projectileDefinition);
       }
 
       return projectiles.isEmpty() ? null : new ProjectileModule(ImmutableSet.copyOf(projectiles));
     }
+
+    private static final Map<String, ProjectileDefinition.ProjectileEntity.AbstractEntity> ABSTRACT_ENTITY_MAP =
+        ImmutableMap.of(
+          "block", new ProjectileDefinition.ProjectileEntity.AbstractEntity(
+                  ProjectileDefinition.ProjectileEntity.AbstractEntityType.BLOCK
+              )
+        );
+
+    private static ProjectileDefinition.ProjectileEntity parseProjectileEntity(
+      final Element element,
+      final String attributeName,
+      final Class<? extends Entity> def
+    ) throws InvalidXMLException {
+      final Node node = Node.fromAttr(element, attributeName);
+      if (node == null) {
+        return new ProjectileDefinition.ProjectileEntity.RealEntity(def);
+      }
+      final String entityText = node.getValue();
+      if (!entityText.matches("[a-zA-Z0-9_]+")) {
+        throw new InvalidXMLException("Invalid entity type '" + entityText + "'", node);
+      }
+      if (ABSTRACT_ENTITY_MAP.containsKey(entityText.toLowerCase())) {
+        return ABSTRACT_ENTITY_MAP.get(entityText.toLowerCase());
+      }
+      return new ProjectileDefinition.ProjectileEntity.RealEntity(XMLUtils.parseEntityTypeAttribute(element, attributeName, def));
+    }
+
+    private static boolean acceptsBlockMaterial(final ProjectileDefinition.ProjectileEntity entity) {
+      if (entity instanceof ProjectileDefinition.ProjectileEntity.RealEntity) {
+        final Class<? extends Entity> cls = ((ProjectileDefinition.ProjectileEntity.RealEntity) entity).entityType;
+        return cls.isAssignableFrom(FallingBlock.class) || NMSHacks.NMS_HACKS.isBlockDisplayEntity(cls);
+      } else if (entity instanceof ProjectileDefinition.ProjectileEntity.AbstractEntity) {
+        return ((ProjectileDefinition.ProjectileEntity.AbstractEntity) entity).entityType ==
+                ProjectileDefinition.ProjectileEntity.AbstractEntityType.BLOCK;
+      }
+      return false;
+    }
   }
 }