diff --git a/src/main/java/ch/njol/skript/Skript.java b/src/main/java/ch/njol/skript/Skript.java index 3755525edb1..3ce91ce0a41 100644 --- a/src/main/java/ch/njol/skript/Skript.java +++ b/src/main/java/ch/njol/skript/Skript.java @@ -34,6 +34,7 @@ import ch.njol.skript.events.EvtSkript; import ch.njol.skript.hooks.Hook; import ch.njol.skript.lang.Condition; +import ch.njol.skript.lang.Condition.ConditionType; import ch.njol.skript.lang.Effect; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.ExpressionInfo; @@ -85,8 +86,10 @@ import ch.njol.util.StringUtils; import ch.njol.util.coll.iterator.CheckedIterator; import ch.njol.util.coll.iterator.EnumerationIterable; + import com.google.common.collect.Lists; import com.google.gson.Gson; + import org.bstats.bukkit.Metrics; import org.bstats.charts.SimplePie; import org.bukkit.Bukkit; @@ -1375,10 +1378,29 @@ public static SkriptAddon getAddonInstance() { // ================ CONDITIONS & EFFECTS & SECTIONS ================ - private static final Collection> conditions = new ArrayList<>(50); - private static final Collection> effects = new ArrayList<>(50); - private static final Collection> statements = new ArrayList<>(100); - private static final Collection> sections = new ArrayList<>(50); + private static final List> conditions = new ArrayList<>(50); + private static final List> effects = new ArrayList<>(50); + private static final List> statements = new ArrayList<>(100); + private static final List> sections = new ArrayList<>(50); + + public static Collection> getStatements() { + return statements; + } + + public static Collection> getEffects() { + return effects; + } + + public static Collection> getSections() { + return sections; + } + + // ================ CONDITIONS ================ + public static Collection> getConditions() { + return conditions; + } + + private final static int[] conditionTypesStartIndices = new int[ConditionType.values().length]; /** * registers a {@link Condition}. @@ -1386,12 +1408,25 @@ public static SkriptAddon getAddonInstance() { * @param condition The condition's class * @param patterns Skript patterns to match this condition */ - public static void registerCondition(final Class condition, final String... patterns) throws IllegalArgumentException { + public static void registerCondition(Class condition, String... patterns) throws IllegalArgumentException { + registerCondition(condition, ConditionType.COMBINED, patterns); + } + + /** + * registers a {@link Condition}. + * + * @param condition The condition's class + * @param type The conditions {@link ConditionType type}. This is used to determine in which order to try to parse conditions. + * @param patterns Skript patterns to match this condition + */ + public static void registerCondition(Class condition, ConditionType type, String... patterns) throws IllegalArgumentException { checkAcceptRegistrations(); String originClassPath = Thread.currentThread().getStackTrace()[2].getClassName(); final SyntaxElementInfo info = new SyntaxElementInfo<>(patterns, condition, originClassPath); - conditions.add(info); - statements.add(info); + conditions.add(conditionTypesStartIndices[type.ordinal()], info); + statements.add(conditionTypesStartIndices[type.ordinal()], info); + for (int i = type.ordinal(); i < ConditionType.values().length; i++) + conditionTypesStartIndices[i]++; } /** @@ -1422,22 +1457,6 @@ public static void registerSection(Class section, String. sections.add(info); } - public static Collection> getStatements() { - return statements; - } - - public static Collection> getConditions() { - return conditions; - } - - public static Collection> getEffects() { - return effects; - } - - public static Collection> getSections() { - return sections; - } - // ================ EXPRESSIONS ================ private final static List> expressions = new ArrayList<>(100); diff --git a/src/main/java/ch/njol/skript/conditions/CondCompare.java b/src/main/java/ch/njol/skript/conditions/CondCompare.java index 186a1f849d6..b6caa0f078c 100644 --- a/src/main/java/ch/njol/skript/conditions/CondCompare.java +++ b/src/main/java/ch/njol/skript/conditions/CondCompare.java @@ -19,17 +19,17 @@ package ch.njol.skript.conditions; import ch.njol.skript.lang.VerboseAssert; + import ch.njol.skript.log.ParseLogHandler; import org.bukkit.event.Event; import org.eclipse.jdt.annotation.Nullable; - -import ch.njol.skript.Skript; -import ch.njol.skript.classes.ClassInfo; - import org.skriptlang.skript.lang.comparator.Comparator; import org.skriptlang.skript.lang.comparator.ComparatorInfo; +import org.skriptlang.skript.lang.comparator.Comparators; import org.skriptlang.skript.lang.comparator.Relation; +import ch.njol.skript.Skript; +import ch.njol.skript.classes.ClassInfo; import ch.njol.skript.doc.Description; import ch.njol.skript.doc.Examples; import ch.njol.skript.doc.Name; @@ -45,8 +45,6 @@ import ch.njol.skript.log.ErrorQuality; import ch.njol.skript.log.SkriptLogger; import ch.njol.skript.registrations.Classes; - -import org.skriptlang.skript.lang.comparator.Comparators; import ch.njol.skript.util.Patterns; import ch.njol.skript.util.Utils; import ch.njol.util.Checker; @@ -95,7 +93,7 @@ public class CondCompare extends Condition implements VerboseAssert { }); static { - Skript.registerCondition(CondCompare.class, patterns.getPatterns()); + Skript.registerCondition(CondCompare.class, ConditionType.PATTERN_MATCHES_EVERYTHING, patterns.getPatterns()); } private Expression first; diff --git a/src/main/java/ch/njol/skript/conditions/base/PropertyCondition.java b/src/main/java/ch/njol/skript/conditions/base/PropertyCondition.java index 528b216ffc7..3d83a8f8710 100644 --- a/src/main/java/ch/njol/skript/conditions/base/PropertyCondition.java +++ b/src/main/java/ch/njol/skript/conditions/base/PropertyCondition.java @@ -63,13 +63,13 @@ public enum PropertyType { * also possibly in the negated form */ BE, - + /** * Indicates that the condition is in a form of something can something, * also possibly in the negated form */ CAN, - + /** * Indicates that the condition is in a form of something has/have something, * also possibly in the negated form @@ -108,17 +108,17 @@ public static void register(Class condition, PropertyType p switch (propertyType) { case BE: - Skript.registerCondition(condition, + Skript.registerCondition(condition, ConditionType.PROPERTY, "%" + type + "% (is|are) " + property, "%" + type + "% (isn't|is not|aren't|are not) " + property); break; case CAN: - Skript.registerCondition(condition, + Skript.registerCondition(condition, ConditionType.PROPERTY, "%" + type + "% can " + property, "%" + type + "% (can't|cannot|can not) " + property); break; case HAVE: - Skript.registerCondition(condition, + Skript.registerCondition(condition, ConditionType.PROPERTY, "%" + type + "% (has|have) " + property, "%" + type + "% (doesn't|does not|do not|don't) have " + property); break; @@ -133,9 +133,9 @@ public static void register(Class condition, PropertyType p } @Override + @SuppressWarnings("unchecked") public boolean init(Expression[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { expr = (Expression) expressions[0]; - setNegated(matchedPattern == 1); return true; } @@ -147,7 +147,7 @@ public final boolean check(Event event) { @Override public abstract boolean check(T value); - + protected abstract String getPropertyName(); protected PropertyType getPropertyType() { @@ -176,15 +176,17 @@ public static String toString(Condition condition, PropertyType propertyType, @N case CAN: return expr.toString(event, debug) + (condition.isNegated() ? " can't " : " can ") + property; case HAVE: - if (expr.isSingle()) + if (expr.isSingle()) { return expr.toString(event, debug) + (condition.isNegated() ? " doesn't have " : " has ") + property; - else + } else { return expr.toString(event, debug) + (condition.isNegated() ? " don't have " : " have ") + property; + } case WILL: return expr.toString(event, debug) + (condition.isNegated() ? " won't " : " will ") + "be " + property; default: assert false; - throw new AssertionError(); + return null; } } + } diff --git a/src/main/java/ch/njol/skript/lang/Condition.java b/src/main/java/ch/njol/skript/lang/Condition.java index 3388f43bbc0..9ba8c40e853 100644 --- a/src/main/java/ch/njol/skript/lang/Condition.java +++ b/src/main/java/ch/njol/skript/lang/Condition.java @@ -33,6 +33,25 @@ */ public abstract class Condition extends Statement { + public enum ConditionType { + /** + * Conditions that contain other expressions, e.g. "%properties% is/are within %expressions%" + * + * @see #PROPERTY + */ + COMBINED, + + /** + * Property conditions, e.g. "%properties% is/are data value[s]" + */ + PROPERTY, + + /** + * Conditions whose pattern matches (almost) everything or should be last checked. + */ + PATTERN_MATCHES_EVERYTHING; + } + private boolean negated; protected Condition() {} @@ -67,6 +86,13 @@ public final boolean isNegated() { return negated; } + /** + * Parse a raw string input as a condition. + * + * @param input The string input to parse as a condition. + * @param defaultError The error if the condition fails. + * @return Condition if parsed correctly, otherwise null. + */ public static @Nullable Condition parse(String input, @Nullable String defaultError) { input = input.trim(); while (input.startsWith("(") && SkriptParser.next(input, 0, ParseContext.DEFAULT) == input.length()) diff --git a/src/test/skript/tests/regressions/5804-is-burning.sk b/src/test/skript/tests/regressions/5804-is-burning.sk new file mode 100644 index 00000000000..d3e01711dc6 --- /dev/null +++ b/src/test/skript/tests/regressions/5804-is-burning.sk @@ -0,0 +1,9 @@ +test "burning": + spawn a pig at event-location + set {_pig} to the last spawned pig + assert "burning" parsed as damage cause is burning with "burning damage cause compare" + set burning time of {_pig} to 9000 ticks + wait a tick + assert entity within {_pig} is burning with "is burning failed" + assert {_pig} is burning with "is burning failed ##2" + clear entity within {_pig}