src/main/java/com/btk5h/skriptdb/SkriptUtil.java

@@ -1,85 +1,94 @@
 package com.btk5h.skriptdb;
 
-import ch.njol.skript.Skript;
-import ch.njol.skript.lang.Expression;
-import ch.njol.skript.lang.VariableString;
-
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.Optional;
 
+import org.bukkit.event.Event;
+
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.VariableString;
+import ch.njol.skript.lang.parser.ParserInstance;
+
 public class SkriptUtil {
+
     private static final Field STRING;
     private static final Field EXPR;
 
     static {
-		Field stringField = null;
+        STRING = tryGetOldStringField()
-		Field exprField = null;
+                .or(() -> tryGetNewStringField())
-
+                .orElseGet(() -> {
-		String[] possibleStringFields = {"string", "stringValue", "rawString"};
+                    Skript.error("Skript's 'string' field could not be resolved.");
-		for (String fieldName : possibleStringFields) {
+                    return null;
-			try {
+                });
-				stringField = VariableString.class.getDeclaredField(fieldName);
-				stringField.setAccessible(true);
-				break;
-			} catch (NoSuchFieldException ignored) {}
-		}
-
-		if (stringField == null) {
-			for (Field field : VariableString.class.getDeclaredFields()) {
-				if (field.getType().isArray() && field.getType().getComponentType() == Object.class) {
-					try {
-						field.setAccessible(true);
-						stringField = field;
-						break;
-					} catch (SecurityException ignored) {}
-				}
-			}
-		}
 
+        Field f = null;
         try {
             Optional<Class<?>> expressionInfo = Arrays.stream(VariableString.class.getDeclaredClasses())
                     .filter(cls -> cls.getSimpleName().equals("ExpressionInfo"))
                     .findFirst();
-
             if (expressionInfo.isPresent()) {
                 Class<?> expressionInfoClass = expressionInfo.get();
-				try {
+                f = expressionInfoClass.getDeclaredField("expr");
-					exprField = expressionInfoClass.getDeclaredField("expr");
+                f.setAccessible(true);
-					exprField.setAccessible(true);
+            } else {
+                Skript.error("Skript's 'ExpressionInfo' class could not be resolved.");
+            }
         } catch (NoSuchFieldException e) {
-					for (Field field : expressionInfoClass.getDeclaredFields()) {
+            e.printStackTrace();
-						if (Expression.class.isAssignableFrom(field.getType())) {
+            Skript.error("Skript's 'expr' field could not be resolved.");
-							field.setAccessible(true);
-							exprField = field;
-							break;
-						}
-					}
-				}
-			}
-		} catch (Exception ignored) {}
-
-		STRING = stringField;
-		EXPR = exprField;
-
-		if (STRING == null && EXPR == null) {
-			Skript.error("Failed to initialize SkriptUtil: Could not find required fields");
         }
+        EXPR = f;
     }
 
     public static Object[] getTemplateString(VariableString vs) {
         try {
-			return STRING != null ? (Object[]) STRING.get(vs) : new Object[]{vs.toString()};
+            return (Object[]) STRING.get(vs);
         } catch (IllegalAccessException e) {
-			return new Object[]{vs.toString()};
+            throw new RuntimeException(e);
         }
     }
 
     public static Expression<?> getExpressionFromInfo(Object o) {
         try {
-			return EXPR != null ? (Expression<?>) EXPR.get(o) : null;
+            return (Expression<?>) EXPR.get(o);
         } catch (IllegalAccessException e) {
-			return null;
+            throw new RuntimeException(e);
         }
     }
+    
+    @SuppressWarnings("deprecation")
+	public static boolean isCurrentEvent(Class<? extends Event> event) {
+        try {
+            Class.forName("ch.njol.skript.lang.parser.ParserInstance");
+            return ParserInstance.get().isCurrentEvent(event);
+        } catch (ClassNotFoundException e) {
+            return ScriptLoader.isCurrentEvent(event);
+        }
+    }
+    
+    
+    private static Optional<Field> tryGetOldStringField() {
+        try {
+            Field f = VariableString.class.getDeclaredField("string");
+            f.setAccessible(true);
+            return Optional.of(f);
+        } catch (NoSuchFieldException e) {
+            return Optional.empty();
+        }
+    }
+    
+    private static Optional<Field> tryGetNewStringField() {
+        try {
+            Field f = VariableString.class.getDeclaredField("strings");
+            f.setAccessible(true);
+            return Optional.of(f);
+        } catch (NoSuchFieldException e) {
+            return Optional.empty();
+        }
+    }
+
 }