Bezier Curves, new Point class, slightly better error handling

Author: sovdeeth

build.gradle

@@ -25,8 +25,8 @@ repositories {
 }
 
 dependencies {
-    compileOnly("io.papermc.paper:paper-api:1.20.2-R0.1-SNAPSHOT")
-    compileOnly("com.github.SkriptLang:Skript:2.7.0")
+    compileOnly("io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT")
+    compileOnly("com.github.SkriptLang:Skript:2.8.4")
     shadow "org.bstats:bstats-bukkit:3.0.2"
     implementation "org.joml:joml:${jomlVersion}"
 }

src/main/java/com/sovdee/skriptparticles/elements/expressions/constructors/ExprBezierCurve.java

@@ -0,0 +1,72 @@
+package com.sovdee.skriptparticles.elements.expressions.constructors;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+import com.sovdee.skriptparticles.shapes.BezierCurve;
+import com.sovdee.skriptparticles.shapes.Circle;
+import com.sovdee.skriptparticles.shapes.Shape;
+import com.sovdee.skriptparticles.util.MathUtil;
+import com.sovdee.skriptparticles.util.Point;
+import org.bukkit.event.Event;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExprBezierCurve extends SimpleExpression<BezierCurve> {
+
+    static {
+        Skript.registerExpression(ExprBezierCurve.class, BezierCurve.class, ExpressionType.COMBINED,
+            "[a] [bezier] curve from [start] %vector/entity/location% to [end] %vector/entity/location% (with|using) control point[s] %vectors/entities/locations%");
+    }
+
+    private Expression<?> start;
+    private Expression<?> end;
+    private Expression<?> controlPoints;
+
+    @Override
+    public boolean init(Expression<?>[] exprs, int matchedPattern, @NonNull Kleenean isDelayed, @NonNull ParseResult parseResult) {
+        start = exprs[0];
+        end = exprs[1];
+        controlPoints = exprs[2];
+        return true;
+    }
+
+    @Override
+    protected BezierCurve @Nullable [] get(@NonNull Event event) {
+        @Nullable Point<?> start = Point.of(this.start.getSingle(event));
+        @Nullable Point<?> end = Point.of(this.end.getSingle(event));
+        if (start == null || end == null)
+            return null;
+        List<Point<?>> controlPoints = new ArrayList<>();
+        for (Object value : this.controlPoints.getArray(event)) {
+            controlPoints.add(Point.of(value));
+        }
+
+        return new BezierCurve[]{new BezierCurve(start, end, controlPoints)};
+    }
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    @NonNull
+    public Class<? extends BezierCurve> getReturnType() {
+        return BezierCurve.class;
+    }
+
+    @Override
+    @NonNull
+    public String toString(@Nullable Event event, boolean debug) {
+        return "bezier curve between start " + start.toString(event, debug) + " and end " + end.toString(event, debug) +
+                " using control points " + controlPoints.toString(event, debug);
+    }
+}

src/main/java/com/sovdee/skriptparticles/elements/sections/DrawShapeEffectSection.java

@@ -15,6 +15,7 @@
 import ch.njol.skript.util.Timespan;
 import ch.njol.skript.variables.Variables;
 import ch.njol.util.Kleenean;
+import com.sovdee.skriptparticles.SkriptParticle;
 import com.sovdee.skriptparticles.shapes.Shape;
 import com.sovdee.skriptparticles.util.DynamicLocation;
 import org.bukkit.Bukkit;
@@ -35,7 +36,7 @@
 
 public abstract class DrawShapeEffectSection extends EffectSection {
 
-    public static final Timespan ONE_TICK = Timespan.fromTicks_i(1);
+    public static final Timespan ONE_TICK = Timespan.fromTicks(1);
 
     static {
         EventValues.registerEventValue(DrawEvent.class, Shape.class, new Getter<>() {
@@ -105,7 +106,7 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean is
      * @param hasSection Whether this section had a valid section body.
      * @return Whether this expression was initialised successfully. An error should be printed prior to returning false to specify the cause
      */
-    public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, boolean hasSection) {
+    public boolean init(@Nullable Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, boolean hasSection) {
         shapes = (Expression<Shape>) expressions[0];
 
         if (expressions[2] != null) {
@@ -136,9 +137,9 @@ protected TriggerItem walk(Event event) {
             recipients.addAll(Bukkit.getOnlinePlayers());
         }
 
-        Object localVars = Variables.copyLocalVariables(event);
+        @Nullable Object localVars = Variables.copyLocalVariables(event);
 
-        Consumer<Shape> consumer;
+        @Nullable Consumer<Shape> consumer;
         if (trigger != null) {
             consumer = shape -> {
                 DrawEvent drawEvent = new DrawEvent(shape);
@@ -153,10 +154,11 @@ protected TriggerItem walk(Event event) {
 
         // Figure out what locations to draw at, or what entities to follow
         List<DynamicLocation> locations = new ArrayList<>();
-        Direction direction = null;
+        @Nullable Direction direction = null;
         if (!useShapeLocation) {
             if (directions != null)
                 direction = directions.getSingle(event);
+            assert this.locations != null;
             for (Object location : this.locations.getArray(event)) {
                 if (location instanceof Entity) {
                     locations.add(new DynamicLocation((Entity) location, direction));
@@ -207,26 +209,42 @@ public void run() {
         runnable.runTaskAsynchronously(Skript.getInstance());
     }
 
-    protected void executeSync(Event event, Collection<DynamicLocation> locations, Consumer<Shape> consumer, Collection<Player> recipients) {
+    protected void executeSync(Event event, Collection<DynamicLocation> locations, @Nullable Consumer<Shape> consumer, Collection<Player> recipients) {
         Shape shapeCopy;
-        for (DynamicLocation dynamicLocation : locations) {
-            for (Shape shape : shapes.getArray(event)) {
-                if (consumer != null) {
-                    // copy the shape so that it can be modified by the consumer without affecting the original
-                    shapeCopy = shape.clone();
-                    shapeCopy.draw(dynamicLocation, consumer, recipients);
-                } else {
-                    shape.draw(dynamicLocation, recipients);
+        try {
+            for (DynamicLocation dynamicLocation : locations) {
+                for (Shape shape : shapes.getArray(event)) {
+                    if (consumer != null) {
+                        // copy the shape so that it can be modified by the consumer without affecting the original
+                        shapeCopy = shape.clone();
+                        shapeCopy.draw(dynamicLocation, consumer, recipients);
+                    } else {
+                        shape.draw(dynamicLocation, recipients);
+                    }
                 }
             }
+        } catch (IllegalArgumentException exception) {
+            SkriptParticle.severe("Unable to draw shape[s]! Please check that your particles are valid!");
+            SkriptParticle.severe("Exception: " + exception.getMessage());
+            SkriptParticle.severe("To see the full stack trace, set Skript's verbosity to very high or debug.");
+            if (Skript.logVeryHigh())
+                exception.printStackTrace();
         }
     }
 
     protected void executeAsync(Collection<DynamicLocation> locations, Collection<Shape> shapes, Collection<Player> recipients) {
-        for (DynamicLocation dynamicLocation : locations) {
-            for (Shape shape : shapes) {
-                shape.draw(dynamicLocation, recipients);
+        try {
+            for (DynamicLocation dynamicLocation : locations) {
+                for (Shape shape : shapes) {
+                    shape.draw(dynamicLocation, recipients);
+                }
             }
+        } catch (IllegalArgumentException exception) {
+            SkriptParticle.severe("Unable to draw shape[s]! Please check that your particles are valid!");
+            SkriptParticle.severe("Exception: " + exception.getMessage());
+            SkriptParticle.severe("To see the full stack trace, set Skript's verbosity to very high or debug.");
+            if (Skript.logVeryHigh())
+                exception.printStackTrace();
         }
     }
 

src/main/java/com/sovdee/skriptparticles/elements/sections/EffSecDrawShape.java

@@ -72,7 +72,7 @@ public Shape get(EffSecDrawShape.DrawEvent event) {
     private Expression<Timespan> delay;
 
     @Override
-    public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, boolean hasSection) {
+    public boolean init(@Nullable Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, boolean hasSection) {
         if (parseResult.hasTag("duration")) {
             duration = (Expression<Timespan>) expressions[4];
             delay = (Expression<Timespan>) expressions[5];
@@ -91,8 +91,8 @@ protected void setupAsync(Event event, Collection<DynamicLocation> locations, Co
             @Nullable Timespan duration = this.duration.getSingle(event);
             if (delay == null || duration == null) return;
 
-            period = Math.max(delay.getTicks_i(), 1);
-            iterations = Math.max(duration.getTicks_i() / period, 1);
+            period = Math.max(delay.getTicks(), 1);
+            iterations = Math.max(duration.getTicks() / period, 1);
         }
         AtomicLong currentIteration = new AtomicLong(0);
         BukkitRunnable runnable = new BukkitRunnable() {

src/main/java/com/sovdee/skriptparticles/elements/sections/EffSecDrawShapeAnimation.java

@@ -14,7 +14,7 @@
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
 import org.checkerframework.checker.nullness.qual.NonNull;
-import org.jetbrains.annotations.Nullable;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.Collection;
 import java.util.function.Consumer;
@@ -36,7 +36,7 @@ public class EffSecDrawShapeAnimation extends DrawShapeEffectSection {
     private Expression<Timespan> duration;
 
     @Override
-    public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, boolean hasSection) {
+    public boolean init(@Nullable Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult, boolean hasSection) {
         duration = (Expression<Timespan>) expressions[4];
         return super.init(expressions, matchedPattern, isDelayed, parseResult, hasSection);
     }
@@ -45,13 +45,13 @@ public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean is
      * This method should not be called for this section.
      */
     @Override
-    protected void executeSync(Event event, Collection<DynamicLocation> locations, Consumer<Shape> consumer, Collection<Player> recipients) {
+    protected void executeSync(Event event, Collection<DynamicLocation> locations, @Nullable Consumer<Shape> consumer, Collection<Player> recipients) {
         // intentionally empty
     }
 
     @Override
     protected void setupAsync(Event event, Collection<DynamicLocation> locations, Collection<Shape> shapes, Collection<Player> recipients) {
-        Timespan duration = this.duration.getOptionalSingle(event).orElse(Timespan.fromTicks_i(0));
+        Timespan duration = this.duration.getOptionalSingle(event).orElse(Timespan.fromTicks(0));
         long milliseconds = duration.getMilliSeconds();
         for (Shape shape : shapes) {
             shape.setAnimationDuration(milliseconds);

src/main/java/com/sovdee/skriptparticles/shapes/BezierCurve.java

@@ -0,0 +1,122 @@
+package com.sovdee.skriptparticles.shapes;
+
+import com.sovdee.skriptparticles.util.DynamicLocation;
+import com.sovdee.skriptparticles.util.Point;
+import com.sovdee.skriptparticles.util.Quaternion;
+import org.bukkit.Location;
+import org.bukkit.util.Vector;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.jetbrains.annotations.Contract;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+public class BezierCurve extends AbstractShape {
+
+    private Point<?> start;
+    private Point<?> end;
+    private List<Point<?>> controlPoints;
+
+    private boolean isDynamic;
+
+    /**
+     * Creates a new line shape with the start point at the origin and the end point at the given vector.
+     * The vector cannot be the origin.
+     * @param end the end point of the line
+     * @throws IllegalArgumentException if the end vector is the origin
+     */
+
+    public BezierCurve(Point<?> start, Point<?> end, List<Point<?>> controlPoints) {
+        this.start = start;
+        if (start.getType() != Vector.class)
+            this.setLocation(start.getDynamicLocation());
+        this.end = end;
+        this.controlPoints = new ArrayList<>(controlPoints);
+        isDynamic = true;
+    }
+
+    public BezierCurve(BezierCurve curve) {
+        this.start = curve.getStart();
+        this.end = curve.getEnd();
+        this.controlPoints = new ArrayList<>(curve.getControlPoints());
+        isDynamic = curve.isDynamic;
+    }
+
+    @Override
+    @Contract(pure = true)
+    public Set<Vector> getPoints(Quaternion orientation) {
+        Set<Vector> points = super.getPoints(orientation);
+        if (isDynamic)
+            // Ensure that the points are always needing to be updated if the start or end location is dynamic
+            this.setNeedsUpdate(true);
+        return points;
+    }
+
+    private List<Vector> evaluateControlPoints() {
+        List<Vector> controlPoints = new ArrayList<>();
+        @Nullable Location origin = start.getLocation();
+        controlPoints.add(start.getVector(origin));
+        for (Point<?> controlPoint : this.controlPoints)
+            controlPoints.add(controlPoint.getVector(origin));
+        controlPoints.add(end.getVector(origin));
+        return controlPoints;
+    }
+
+    @Override
+    public Set<Vector> generateOutline() {
+        Set<Vector> points = new LinkedHashSet<>();
+        List<Vector> controlPoints = evaluateControlPoints();
+
+        int steps = (int) (estimateLength(controlPoints) / getParticleDensity());
+
+        for (double step = 0; step < steps; step++) {
+            double t = step / steps;
+            double nt = 1 - t;
+            List<Vector> tempCP = new ArrayList<>(controlPoints);
+            while (tempCP.size() > 1) {
+                for (int i = 0; i < tempCP.size() - 1; i++)
+                    tempCP.set(i, tempCP.get(i).clone().multiply(nt).add(tempCP.get(i + 1).clone().multiply(t)));
+                tempCP.remove(tempCP.size()-1);
+            }
+            points.add(tempCP.get(0));
+        }
+        return points;
+    }
+
+    private double estimateLength() {
+        return estimateLength(evaluateControlPoints());
+    }
+    private double estimateLength(List<Vector> controlPoints) {
+        double dist = 0;
+        for (int i = 0; i < controlPoints.size()-1; i++) {
+            dist += controlPoints.get(i).distance(controlPoints.get(i+1));
+        }
+        return dist;
+    }
+
+    @Override
+    public void setParticleCount(int particleCount) {
+        particleCount = Math.max(particleCount, 1);
+        this.setParticleDensity(estimateLength() / particleCount);
+        this.setNeedsUpdate(true);
+    }
+
+    public Point<?> getStart() {
+        return start;
+    }
+
+    public Point<?> getEnd() {
+        return end;
+    }
+
+    public List<Point<?>> getControlPoints() {
+        return controlPoints;
+    }
+
+    @Override
+    public Shape clone() {
+        return this.copyTo(new BezierCurve(this));
+    }
+}