ch.njol.skript.lang.Condition Java Examples

/**
 * @param c the class to register
 * @param propertyType the property type, see {@link PropertyType}
 * @param property the property name, for example <i>fly</i> in <i>players can fly</i>
 * @param type must be plural, for example <i>players</i> in <i>players can fly</i>
 */
public static void register(final Class<? extends Condition> c, final PropertyType propertyType, final String property, final String type) {
	if (type.contains("%")) {
		throw new SkriptAPIException("The type argument must not contain any '%'s");
	}
	switch (propertyType) {
		case BE:
			Skript.registerCondition(c,
					"%" + type + "% (is|are) " + property,
					"%" + type + "% (isn't|is not|aren't|are not) " + property);
			break;
		case CAN:
			Skript.registerCondition(c,
					"%" + type + "% can " + property,
					"%" + type + "% (can't|cannot|can not) " + property);
			break;
		case HAVE:
			Skript.registerCondition(c,
					"%" + type + "% (has|have) " + property,
					"%" + type + "% (doesn't|does not|do not|don't) have " + property);
			break;
		default:
			assert false;
	}
}
 

public static String toString(Condition condition, PropertyType propertyType, @Nullable Event e,
							  boolean debug, Expression<?> expr, String property) {
	switch (propertyType) {
		case BE:
			return expr.toString(e, debug) + (expr.isSingle() ? " is " : " are ") + (condition.isNegated() ? "not " : "") + property;
		case CAN:
			return expr.toString(e, debug) + (condition.isNegated() ? " can't " : " can ") + property;
		case HAVE:
			if (expr.isSingle())
				return expr.toString(e, debug) + (condition.isNegated() ? " doesn't have " : " has ") + property;
			else
				return expr.toString(e, debug) + (condition.isNegated() ? " don't have " : " have ") + property;
		default:
			assert false;
			throw new AssertionError();
	}
}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
	try {
		parsing = this;
		objects = LiteralUtils.defendExpression(exprs[0]);
		rawCond = parseResult.regexes.get(0).group();
		condition = Condition.parse(rawCond, "Can't understand this condition: " + rawCond);
	} finally {
		parsing = null;
	}
	return condition != null && LiteralUtils.canInitSafely(objects);
}
 

@Override
@SuppressWarnings("unchecked")
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
	ifTrue = LiteralUtils.defendExpression(exprs[0]);
	ifFalse = LiteralUtils.defendExpression(exprs[1]);
	if (ifFalse instanceof ExprTernary<?> || ifTrue instanceof ExprTernary<?>) {
		Skript.error("Ternary operators may not be nested!");
		return false;
	}
	String cond = parseResult.regexes.get(0).group();
	condition = Condition.parse(cond, "Can't understand this condition: " + cond);
	return condition != null && LiteralUtils.canInitSafely(ifTrue, ifFalse);
}
 

/**
 * registers a {@link Condition}.
 * 
 * @param condition The condition's class
 * @param patterns Skript patterns to match this condition
 */
public static <E extends Condition> void registerCondition(final Class<E> condition, final String... patterns) throws IllegalArgumentException {
	checkAcceptRegistrations();
	String originClassPath = Thread.currentThread().getStackTrace()[2].getClassName();
	final SyntaxElementInfo<E> info = new SyntaxElementInfo<>(patterns, condition, originClassPath);
	conditions.add(info);
	statements.add(info);
}
 

@SuppressWarnings({"null", "unchecked"})
@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
	String cond = parseResult.regexes.get(0).group();
	condition = Condition.parse(cond, "Can't understand this condition: " + cond);
	errorMsg = (Expression<String>) exprs[0];
	return condition != null;
}
 

@SuppressWarnings({"null", "unchecked"})
@Override
public boolean init(Literal<?>[] args, int matchedPattern, SkriptParser.ParseResult parseResult) {
	name = (Expression<String>) args[0];
	if (!parseResult.regexes.isEmpty()) { // Do not parse or run unless condition is met
		String cond = parseResult.regexes.get(0).group();
		condition = Condition.parse(cond, "Can't understand this condition: " + cond);
	}
	return true;
}
 

@SuppressWarnings("null")
@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
	String eff = parseResult.regexes.get(0).group();
	String cond = parseResult.regexes.get(1).group();
	effect = Effect.parse(eff, "Can't understand this effect: " + eff);
	if (effect instanceof EffDoIf) {
		Skript.error("Do if effects may not be nested!");
		return false;
	}
	condition = Condition.parse(cond, "Can't understand this condition: " + cond);
	return effect != null && condition != null;
}
 

public static Collection<SyntaxElementInfo<? extends Condition>> getConditions() {
	return conditions;
}
 

/**
 * @param c the class to register
 * @param property the property name, for example <i>fly</i> in <i>players can fly</i>
 * @param type must be plural, for example <i>players</i> in <i>players can fly</i>
 */
public static void register(final Class<? extends Condition> c, final String property, final String type) {
	register(c, PropertyType.BE, property, type);
}