Stars, Hearts, and Bug Fixes

Author: sovdeeth

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

@@ -12,37 +12,39 @@
 import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.util.Kleenean;
 import com.sovdee.skriptparticles.shapes.Heart;
+import com.sovdee.skriptparticles.shapes.Shape;
 import com.sovdee.skriptparticles.util.MathUtil;
 import org.bukkit.event.Event;
 import org.jetbrains.annotations.Nullable;
 
 @Name("Particle Heart")
 @Description({
-        "Creates a heart shape with the given width and height, and optionally eccentricity. The width and height must be greater than 0.",
+        "Creates a heart shape with the given width and height, and optionally eccentricity. The width (x) and length (z) must be greater than 0.",
         "The eccentricity defaults to 3, but must be at least 1. This determines how round/pointy the heart is. Values between 1 and 5 are recommended.",
-        "Note that the width and heights are not exact, but they're roughly the width and height of the heart.",
+        "Note that the width and length are not exact, but they're roughly the width and length of the heart.",
         "Finally, this shape does not support the particle count expression and its particle density is not uniform. If anyone knows a good way to compute the complete elliptic integral of the second kind, please let me know."
 })
 @Examples({
-        "set {_heart} to heart with width 5 and height 4",
-        "set {_heart} to heart shape with width 5, height 7, and eccentricity 2",
-        "draw a heart of width 2 and height 2 at player"
+        "set {_heart} to heart with width 5 and length 4",
+        "set {_heart} to heart shape with width 5, length 7, and eccentricity 2",
+        "draw a heart of width 2 and length 2 at player"
 })
 @Since("1.0.1")
 public class ExprHeart extends SimpleExpression<Heart> {
 
     static {
-        Skript.registerExpression(ExprHeart.class, Heart.class, ExpressionType.COMBINED, "[a] [:solid] heart [shape] (with|of) width %number%[,] [and] height %number%[[,] [and] eccentricity %-number%]");
+        Skript.registerExpression(ExprHeart.class, Heart.class, ExpressionType.COMBINED, "[a] [:solid] heart [shape] (with|of) width %number%[,] [and] length %number%[[,] [and] eccentricity %-number%]");
     }
 
     private Expression<Number> width;
-    private Expression<Number> height;
+    private Expression<Number> length;
     private Expression<Number> eccentricity;
+    private boolean isSolid;
 
     @Override
     public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, ParseResult parseResult) {
         width = (Expression<Number>) expressions[0];
-        height = (Expression<Number>) expressions[1];
+        length = (Expression<Number>) expressions[1];
         if (expressions.length > 2) {
             eccentricity = (Expression<Number>) expressions[2];
         }
@@ -52,8 +54,8 @@ public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, Parse
             return false;
         }
 
-        if (height instanceof Literal<Number> literal && literal.getSingle().doubleValue() <= 0) {
-            Skript.error("The height of a heart must be greater than 0.");
+        if (length instanceof Literal<Number> literal && literal.getSingle().doubleValue() <= 0) {
+            Skript.error("The length of a heart must be greater than 0.");
             return false;
         }
 
@@ -62,23 +64,29 @@ public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, Parse
             return false;
         }
 
+        isSolid = parseResult.hasTag("solid");
+
         return true;
     }
 
     @Override
     @Nullable
     protected Heart[] get(Event event) {
         Number width = this.width.getSingle(event);
-        Number height = this.height.getSingle(event);
+        Number length = this.length.getSingle(event);
         Number eccentricity = this.eccentricity == null ? 3 : this.eccentricity.getSingle(event);
-        if (width == null || height == null || eccentricity == null) {
+        if (width == null || length == null || eccentricity == null) {
             return null;
         }
         width = Math.max(width.doubleValue(), MathUtil.EPSILON);
-        height = Math.max(height.doubleValue(), MathUtil.EPSILON);
+        length = Math.max(length.doubleValue(), MathUtil.EPSILON);
         eccentricity = Math.max(eccentricity.doubleValue(), 1);
 
-        return new Heart[] {new Heart(width.doubleValue(), height.doubleValue(), eccentricity.doubleValue())};
+        Heart heart = new Heart(width.doubleValue(), length.doubleValue(), eccentricity.doubleValue());
+        if (isSolid) {
+            heart.setStyle(Shape.Style.SURFACE);
+        }
+        return new Heart[]{heart};
     }
 
     @Override
@@ -93,6 +101,6 @@ public Class<? extends Heart> getReturnType() {
 
     @Override
     public String toString(@Nullable Event event, boolean b) {
-        return "a heart shape with width " + width.toString(event, b) + ", height " + height.toString(event, b) + ", and eccentricity " + eccentricity.toString(event, b) + ".";
+        return "a heart shape with width " + width.toString(event, b) + ", height " + length.toString(event, b) + ", and eccentricity " + eccentricity.toString(event, b) + ".";
     }
 }

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

@@ -0,0 +1,99 @@
+package com.sovdee.skriptparticles.elements.expressions.constructors;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Name;
+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.Shape;
+import com.sovdee.skriptparticles.shapes.Star;
+import com.sovdee.skriptparticles.util.MathUtil;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+@Name("Particle Star")
+@Description({
+        "Creates a star shape with the given number of points, inner radius, and outer radius. The number of points must be at least 2, and the inner and outer radii must be greater than 0.",
+        "Note that \"points\" in this context is referring to the tips of the star, not the number of particles."
+})
+@Examples({
+        "set {_shape} to star with 5 points, inner radius 1, and outer radius 2",
+        "draw a star with 4 points, inner radius 2, and outer radius 4 at player"
+})
+public class ExprStar extends SimpleExpression<Star> {
+
+    static {
+        Skript.registerExpression(ExprStar.class, Star.class, ExpressionType.COMBINED, "[a] [:solid] star with %number% points(,| and) inner radius %number%[,] and outer radius %number%");
+    }
+
+    private Expression<Number> points;
+    private Expression<Number> innerRadius;
+    private Expression<Number> outerRadius;
+    private boolean isSolid;
+
+    @Override
+    public boolean init(Expression<?>[] expressions, int i, Kleenean kleenean, ParseResult parseResult) {
+        points = (Expression<Number>) expressions[0];
+        innerRadius = (Expression<Number>) expressions[1];
+        outerRadius = (Expression<Number>) expressions[2];
+        isSolid = parseResult.hasTag("solid");
+
+        if (points instanceof Literal<Number> literal && literal.getSingle().doubleValue() < 2) {
+            Skript.error("A star must have at least 2 points. (points: " +
+                    literal.getSingle().doubleValue() + ")");
+            return false;
+        }
+
+        if (innerRadius instanceof Literal<Number> literal && literal.getSingle().doubleValue() <= 0) {
+            Skript.error("The inner radius of a star must be greater than 0.");
+            return false;
+        }
+
+        if (outerRadius instanceof Literal<Number> literal && literal.getSingle().doubleValue() <= 0) {
+            Skript.error("The outer radius of a star must be greater than 0.");
+            return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    @Nullable
+    protected Star[] get(Event event) {
+        Number points = this.points.getSingle(event);
+        Number innerRadius = this.innerRadius.getSingle(event);
+        Number outerRadius = this.outerRadius.getSingle(event);
+        if (points == null || innerRadius == null || outerRadius == null)
+            return null;
+
+        double angle = Math.PI * 2 / Math.max(points.intValue(), 2);
+        innerRadius = Math.max(innerRadius.doubleValue(), MathUtil.EPSILON);
+        outerRadius = Math.max(outerRadius.doubleValue(), MathUtil.EPSILON);
+
+        Star star = new Star(innerRadius.doubleValue(), outerRadius.doubleValue(), angle);
+        if (isSolid)
+            star.setStyle(Shape.Style.SURFACE);
+
+        return new Star[]{star};
+    }
+
+    @Override
+    public boolean isSingle() {
+        return true;
+    }
+
+    @Override
+    public Class<? extends Star> getReturnType() {
+        return Star.class;
+    }
+
+    @Override
+    public String toString(@Nullable Event event, boolean b) {
+        return "a " + (isSolid ? "solid " : "") + "star shape with " + points.toString(event, b) + " points, inner radius " + innerRadius.toString(event, b) + ", and outer radius " + outerRadius.toString(event, b);
+    }
+}

src/main/java/com/sovdee/skriptparticles/elements/expressions/properties/ExprHelixWindingRate.java

@@ -4,6 +4,7 @@
 import ch.njol.skript.doc.Description;
 import ch.njol.skript.doc.Examples;
 import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
 import ch.njol.skript.expressions.base.SimplePropertyExpression;
 import com.sovdee.skriptparticles.shapes.Helix;
 import com.sovdee.skriptparticles.shapes.Shape;
@@ -21,16 +22,19 @@
         "set winding rate of {_helix} to 1/10",
         "set winding rate of {_helix} to 10.4"
 })
-public class ExprHelixWindingRate extends SimplePropertyExpression<Helix, Number> {
+@Since("1.0.0")
+public class ExprHelixWindingRate extends SimplePropertyExpression<Shape, Number> {
 
     static {
         register(ExprHelixWindingRate.class, Number.class, "winding rate", "shapes");
     }
 
     @Override
     @Nullable
-    public Number convert(Helix helix) {
-        return  1 / (2 * Math.PI * helix.getSlope());
+    public Number convert(Shape shape) {
+        if (shape instanceof Helix helix)
+            return  1 / (2 * Math.PI * helix.getSlope());
+        return null;
     }
 
     @Override

src/main/java/com/sovdee/skriptparticles/elements/expressions/properties/ExprStarPoints.java

@@ -0,0 +1,84 @@
+package com.sovdee.skriptparticles.elements.expressions.properties;
+
+import ch.njol.skript.classes.Changer;
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Examples;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.expressions.base.SimplePropertyExpression;
+import com.sovdee.skriptparticles.shapes.Shape;
+import com.sovdee.skriptparticles.shapes.Star;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+
+@Name("Star Points")
+@Description({
+        "Returns the number of points on a star. This is the number of points on the star, not the number of particles drawn.",
+        "Changing this will change the number of points on the star. The number of points must be at least 2."
+})
+@Examples({
+        "set {_shape}'s star points to 5",
+        "set star points of {_shape} to 10",
+        "set star points of {_shape} to 2 * (star points of {_shape})"
+})
+@Since("1.0.1")
+public class ExprStarPoints extends SimplePropertyExpression<Shape, Number> {
+
+    static {
+        register(ExprStarPoints.class, Number.class, "star points", "shapes");
+    }
+
+    @Override
+    public @Nullable Number convert(Shape shape) {
+        if (shape instanceof Star)
+            return ((Star) shape).getStarPoints();
+        return null;
+    }
+
+    @Override
+    public @Nullable Class<?>[] acceptChange(Changer.ChangeMode mode) {
+        return switch (mode) {
+            case SET, ADD, REMOVE -> new Class[]{Number.class};
+            default -> null;
+        };
+    }
+
+    @Override
+    public void change(Event event, @Nullable Object[] delta, Changer.ChangeMode mode) {
+        if (delta == null || delta.length == 0)
+            return;
+        Shape[] shapes = getExpr().getArray(event);
+
+        int deltaValue = ((Number) delta[0]).intValue();
+        switch (mode) {
+            case REMOVE:
+                deltaValue = -deltaValue;
+            case ADD:
+                for (Shape shape : shapes) {
+                    if (shape instanceof Star star) {
+                        star.setStarPoints(Math.max(star.getStarPoints() + deltaValue, 2));
+                    }
+                }
+                break;
+            case SET:
+                deltaValue = Math.max(deltaValue, 2);
+                for (Shape shape : shapes) {
+                    if (shape instanceof Star star) {
+                        star.setStarPoints(deltaValue);
+                    }
+                }
+                break;
+        }
+    }
+
+    @Override
+    public Class<? extends Number> getReturnType() {
+        return Number.class;
+    }
+
+    @Override
+    protected String getPropertyName() {
+        return "star points";
+    }
+
+}